元编程：DSL构建

// 这就是我们期望的 DSL 调用方式
// 看起来像声明式配置，实际上是纯 Kotlin 代码
val person = person {       // person 是一个顶层函数
    name = "Alice"          // name 是接收者对象的属性
    age = 28                // age 同理
    address {               // address 是接收者对象的方法，接受一个 Lambda
        city = "Shanghai"   // 嵌套作用域内的属性
        zip = "200000"
    }
}

// ======== 数据模型层 ========
 
// 地址数据类，存储城市和邮编
data class Address(
    val city: String,       // 城市名称
    val zip: String         // 邮政编码
)
 
// 人员数据类，存储姓名、年龄和可选地址
data class Person(
    val name: String,       // 姓名
    val age: Int,           // 年龄
    val address: Address?   // 地址（可空，允许不填）
)
 
// ======== Builder 层（DSL 的骨架）========
 
// 地址构建器：DSL 用户在 address { ... } 块内操作的就是这个对象
class AddressBuilder {
    var city: String = ""   // 默认空字符串，DSL 用户可直接赋值
    var zip: String = ""    // 同上
 
    // 将 Builder 的可变状态"凝固"为不可变的数据对象
    fun build(): Address = Address(city, zip)
}
 
// 人员构建器：DSL 用户在 person { ... } 块内操作的就是这个对象
class PersonBuilder {
    var name: String = ""   // DSL 用户通过 name = "xxx" 赋值
    var age: Int = 0        // DSL 用户通过 age = 28 赋值
 
    // 持有一个内部的地址构建器引用（初始为 null）
    private var addressBuilder: AddressBuilder? = null
 
    // 这个函数接收一个「以 AddressBuilder 为接收者」的 Lambda
    // 当 DSL 用户写 address { city = "Shanghai" } 时，
    // 花括号内的 this 就指向 AddressBuilder 实例
    fun address(block: AddressBuilder.() -> Unit) {
        val builder = AddressBuilder() // 创建 AddressBuilder 实例
        builder.block()                // 在该实例上执行用户的 Lambda
        addressBuilder = builder       // 保存引用
    }
 
    // 构建最终的 Person 对象
    fun build(): Person = Person(
        name = name,
        age = age,
        address = addressBuilder?.build()  // 如果用户没写 address 块，则为 null
    )
}
 
// ======== DSL 入口函数 ========
 
// 顶层函数：接收一个「以 PersonBuilder 为接收者」的 Lambda
// 这是整个 DSL 的唯一入口
fun person(block: PersonBuilder.() -> Unit): Person {
    val builder = PersonBuilder()   // 创建 PersonBuilder 实例
    builder.block()                 // 在该实例上执行用户传入的配置 Lambda
    return builder.build()          // 返回构建完成的 Person 对象
}

// ========= 光谱最左端：纯命令式 API =========
// 特点：逐步调用，暴露所有实现细节
val builder = PersonBuilder()     // 手动创建 Builder
builder.name = "Alice"            // 逐条设置
builder.age = 28
val addrBuilder = AddressBuilder()
addrBuilder.city = "Shanghai"
addrBuilder.zip = "200000"
builder.setAddress(addrBuilder.build())
val person = builder.build()      // 手动 build
 
// ========= 光谱中间：流畅 API (Fluent API) =========
// 特点：链式调用，但仍然是"方法调用"的外观
val person = PersonBuilder()
    .name("Alice")                // 每个方法返回 this
    .age(28)
    .address(AddressBuilder()
        .city("Shanghai")
        .zip("200000")
        .build())
    .build()
 
// ========= 光谱最右端：内部 DSL =========
// 特点：声明式、嵌套、读起来像配置文件
val person = person {
    name = "Alice"                // 属性赋值 ≠ 方法调用
    age = 28
    address {                     // 嵌套块 ≠ 方法链
        city = "Shanghai"
        zip = "200000"
    }
}

// 这是一段危险的 SQL 拼接（仅用于演示反面模式）
val sql = "SELECT * FROM users WHERE name = '" + userInput + "'"
// 问题 1：SQL 注入风险（userInput 可能包含恶意 SQL）
// 问题 2：语法错误只有运行时才会暴露（字段名拼错、类型不匹配...）
// 问题 3：无 IDE 补全、无重构支持

// ======== HTML DSL 的类型安全结构示例 ========
 
// 所有 HTML 标签的抽象基类
open class Tag(val name: String) {
    // 子标签列表
    val children = mutableListOf<Tag>()
    // 文本内容
    var text: String = ""
 
    override fun toString(): String {
        // 递归渲染 HTML（简化版）
        val childrenHtml = children.joinToString("") { it.toString() }
        val content = text + childrenHtml
        return "<$name>$content</$name>"
    }
}
 
// HTML 标签：只允许添加 head 和 body
class HTML : Tag("html") {
    // head 方法：接收者是 Head，所以 Lambda 内只能用 Head 的方法
    fun head(block: Head.() -> Unit) {
        val head = Head()          // 创建 Head 实例
        head.block()               // 执行 Lambda
        children.add(head)         // 将 head 加入 html 的子标签
    }
 
    // body 方法：同理，接收者是 Body
    fun body(block: Body.() -> Unit) {
        val body = Body()
        body.block()
        children.add(body)
    }
}
 
// Head 标签：只允许添加 title
class Head : Tag("head") {
    fun title(block: Title.() -> Unit) {
        val title = Title()
        title.block()
        children.add(title)
    }
}
 
// Title 标签：只允许设置文本
class Title : Tag("title")
 
// Body 标签：允许添加 h1 和 p
class Body : Tag("body") {
    fun h1(block: H1.() -> Unit) {
        val h1 = H1()
        h1.block()
        children.add(h1)
    }
 
    fun p(block: P.() -> Unit) {
        val p = P()
        p.block()
        children.add(p)
    }
}
 
class H1 : Tag("h1")
class P : Tag("p")
 
// DSL 入口
fun html(block: HTML.() -> Unit): HTML {
    val html = HTML()              // 创建根标签
    html.block()                   // 执行配置 Lambda
    return html                    // 返回构建好的 HTML 树
}

val page = html {
    head {                          // ✅ 合法：HTML 作用域内有 head 方法
        title {                     // ✅ 合法：Head 作用域内有 title 方法
            text = "My Page"        // ✅ 合法：设置文本
        }
    }
    body {                          // ✅ 合法：HTML 作用域内有 body 方法
        h1 { text = "Hello!" }     // ✅ 合法：Body 作用域内有 h1 方法
        p { text = "Welcome" }     // ✅ 合法：Body 作用域内有 p 方法
 
        // title { }               // ❌ 编译错误！Body 内没有 title 方法
        // head { }                // ❌ 编译错误！Body 内没有 head 方法
    }
    // h1 { }                      // ❌ 编译错误！HTML 内没有 h1 方法
}
 
println(page)
// 输出：<html><head><title>My Page</title></head><body><h1>Hello!</h1><p>Welcome</p></body></html>

// 一个类型安全的配置 DSL 片段
// 配置项被泛型参数 T 保护，存取必须类型一致
class ConfigKey<T>(val name: String)    // 泛型键：每个键绑定一个类型 T
 
class ConfigScope {
    // 内部存储（使用 Any? 擦除类型，但对外接口是类型安全的）
    private val map = mutableMapOf<String, Any?>()
 
    // 设置配置值：只接受与 Key 类型匹配的值
    operator fun <T> ConfigKey<T>.invoke(value: T) {
        map[this.name] = value          // 存入 map
    }
 
    // 读取配置值：返回类型自动推断为 T
    @Suppress("UNCHECKED_CAST")
    fun <T> get(key: ConfigKey<T>): T = map[key.name] as T
}
 
// 定义具体的配置键（每个键的类型在定义时就确定）
val port = ConfigKey<Int>("port")        // port 只能存 Int
val host = ConfigKey<String>("host")     // host 只能存 String
val debug = ConfigKey<Boolean>("debug")  // debug 只能存 Boolean
 
fun config(block: ConfigScope.() -> Unit): ConfigScope {
    return ConfigScope().apply(block)
}
 
// 使用 DSL
val cfg = config {
    port(8080)         // ✅ Int -> ConfigKey<Int>，类型匹配
    host("localhost")  // ✅ String -> ConfigKey<String>，类型匹配
    debug(true)        // ✅ Boolean -> ConfigKey<Boolean>，类型匹配
 
    // port("abc")     // ❌ 编译错误！String 不匹配 ConfigKey<Int>
    // debug(42)       // ❌ 编译错误！Int 不匹配 ConfigKey<Boolean>
}

html {
    body {
        // 在 body { } 块内，this 是 Body
        // 但 Kotlin 允许访问外层接收者 HTML 的方法！
        body {
            // 😱 body 里面又嵌了一个 body！
            // 这在语法上是合法的（因为外层 HTML 也有 body 方法）
            // 但在 HTML 语义上是荒谬的
        }
    }
}

// 定义一个普通的高阶函数
// 参数 action 是一个普通 Lambda：接收 StringBuilder 作为参数
fun buildStringNormal(action: (StringBuilder) -> Unit): String {
    val sb = StringBuilder()       // 内部创建 StringBuilder 实例
    action(sb)                     // 将 sb 作为参数传给 Lambda
    return sb.toString()           // 返回最终构建的字符串
}
 
fun main() {
    // 使用时，必须通过参数名 it（或自定义名）来操作 StringBuilder
    val result = buildStringNormal { it ->
        it.append("Hello, ")      // 必须用 it.append
        it.append("World!")       // 每次调用都要带 it 前缀
    }
    println(result) // Hello, World!
}

// 关键变化：参数类型从 (StringBuilder) -> Unit
//          变成了 StringBuilder.() -> Unit
// 这意味着 Lambda 内部的 this 就是 StringBuilder 实例
fun buildStringDSL(action: StringBuilder.() -> Unit): String {
    val sb = StringBuilder()       // 同样创建 StringBuilder 实例
    sb.action()                    // 在 sb 上调用 Lambda，sb 成为 this
    return sb.toString()           // 返回结果
}
 
fun main() {
    // 使用时，Lambda 内部的 this 就是 StringBuilder
    // 可以直接调用 append，就像在 StringBuilder 内部写代码一样
    val result = buildStringDSL {
        append("Hello, ")         // 直接调用，无需前缀！
        append("World!")          // 简洁、自然、流畅
    }
    println(result) // Hello, World!
}

// 通用形式：
// ReceiverType.(ParameterTypes) -> ReturnType
 
// 无参数、无返回值的接收者 Lambda
val greet: StringBuilder.() -> Unit = {
    append("Hi!")                  // this 是 StringBuilder
}
 
// 带参数的接收者 Lambda
val appendLine: StringBuilder.(String) -> Unit = { line ->
    append(line)                   // this 是 StringBuilder
    append("\n")                   // line 是 Lambda 的显式参数
}
 
// 带返回值的接收者 Lambda
val currentLength: StringBuilder.() -> Int = {
    this.length                    // 显式使用 this 访问 length 属性
}

// 扩展函数写法
fun StringBuilder.addExclamation() {
    append("!")                    // this 是 StringBuilder
}
 
// 带接收者的 Lambda 写法（完全等价的语义）
val addExclamation: StringBuilder.() -> Unit = {
    append("!")                    // this 同样是 StringBuilder
}
 
fun main() {
    val sb = StringBuilder("Hello")
 
    // 两种写法的调用方式完全相同
    sb.addExclamation()            // 扩展函数调用
    sb.addExclamation()            // Lambda 变量调用（语法一致）
 
    println(sb) // Hello!!
}

class HtmlBuilder {
    private val elements = mutableListOf<String>() // 存储 HTML 元素
 
    // 添加一个段落标签
    fun p(text: String) {
        elements.add("<p>$text</p>")               // 将段落加入列表
    }
 
    // 添加一个标题标签
    fun h1(text: String) {
        elements.add("<h1>$text</h1>")             // 将标题加入列表
    }
 
    // 构建最终的 HTML 字符串
    fun build(): String = elements.joinToString("\n") // 用换行连接所有元素
}
 
// 高阶函数，接受带接收者的 Lambda
fun html(init: HtmlBuilder.() -> Unit): String {
    val builder = HtmlBuilder()    // 创建构建器实例
    builder.init()                 // 在构建器上执行 Lambda
    return builder.build()         // 返回构建结果
}
 
fun main() {
    val page = html {
        // 此处 this = HtmlBuilder 实例
        h1("Welcome")             // 等价于 this.h1("Welcome")
        p("This is Kotlin DSL")   // 等价于 this.p("This is Kotlin DSL")
    }
    println(page)
    // <h1>Welcome</h1>
    // <p>This is Kotlin DSL</p>
}

class Table {
    private val rows = mutableListOf<String>()     // 存储行数据
 
    // tr 函数接受一个以 Row 为接收者的 Lambda
    fun tr(init: Row.() -> Unit) {
        val row = Row()            // 创建 Row 实例
        row.init()                 // 执行 Lambda，this = Row
        rows.add(row.build())      // 将构建好的行添加到表格
    }
 
    fun build(): String = rows.joinToString("\n")  // 构建表格
}
 
class Row {
    private val cells = mutableListOf<String>()    // 存储单元格
 
    // td 函数添加一个单元格
    fun td(content: String) {
        cells.add("<td>$content</td>")             // 添加单元格标签
    }
 
    fun build(): String = "<tr>${cells.joinToString("")}</tr>" // 构建行
}
 
fun table(init: Table.() -> Unit): String {
    val t = Table()                // 创建 Table 实例
    t.init()                       // 执行 Lambda，this = Table
    return t.build()               // 返回最终 HTML
}
 
fun main() {
    val html = table {             // this: Table
        tr {                       // this: Row（内层遮蔽了外层的 Table）
            td("Cell 1")          // 等价于 this.td("Cell 1")，this = Row
            td("Cell 2")          // 同上
        }
        tr {                       // this: Row（新的 Row 实例）
            td("Cell 3")
            td("Cell 4")
        }
    }
    println(html)
    // <tr><td>Cell 1</td><td>Cell 2</td></tr>
    // <tr><td>Cell 3</td><td>Cell 4</td></tr>
}

class Outer {
    val name = "Outer"
 
    // inner 函数接受以 Inner 为接收者的 Lambda
    fun inner(block: Inner.() -> Unit) {
        Inner().block()            // 创建 Inner 并执行 Lambda
    }
}
 
class Inner {
    val name = "Inner"
}
 
fun buildOuter(init: Outer.() -> Unit): Outer {
    return Outer().apply(init)     // 创建 Outer 并应用初始化 Lambda
}
 
fun main() {
    buildOuter {                   // this: Outer
        println(name)              // "Outer"   — this.name
 
        inner {                    // this: Inner（遮蔽了 Outer）
            println(name)          // "Inner"   — this.name（最近层）
            println(this@inner.name)   // "Inner"   — 显式限定，等价
            println(this@buildOuter.name) // "Outer" — 穿透到外层接收者！
        }
    }
}

class Config {
    var host = "localhost"         // 默认主机
    var port = 8080                // 默认端口
 
    override fun toString() = "$host:$port" // 格式化输出
}
 
// 高阶函数，接受带接收者的 Lambda
fun configure(init: Config.() -> Unit): Config {
    val config = Config()          // 创建配置对象
    config.init()                  // 方式1：像扩展函数一样在对象上调用
    return config
}
 
fun main() {
    // === 方式 1：尾随 Lambda 语法（最常见，最 DSL 风格）===
    val c1 = configure {
        host = "example.com"       // 直接赋值属性
        port = 443                 // 简洁、自然
    }
    println(c1) // example.com:443
 
    // === 方式 2：将 Lambda 存储在变量中再传递 ===
    val myInit: Config.() -> Unit = {
        host = "api.server.com"    // Lambda 变量也可以有接收者类型
        port = 9090
    }
    val c2 = configure(myInit)     // 把变量作为参数传入
    println(c2) // api.server.com:9090
 
    // === 方式 3：传递函数引用（Method Reference）===
    fun Config.productionSetup() {
        host = "prod.server.com"   // 扩展函数可以作为接收者 Lambda 传递
        port = 443
    }
    val c3 = configure(Config::productionSetup) // 函数引用
    println(c3) // prod.server.com:443
}

fun main() {
    // === apply: 接收者是调用对象，返回调用对象本身 ===
    // 签名: public inline fun <T> T.apply(block: T.() -> Unit): T
    val list1 = mutableListOf<Int>().apply {
        add(1)                     // this = MutableList<Int>
        add(2)                     // 直接调用 add
        add(3)
    }
    println(list1) // [1, 2, 3]
 
    // === with: 接收者作为第一个参数传入，返回 Lambda 结果 ===
    // 签名: public inline fun <T, R> with(receiver: T, block: T.() -> R): R
    val csv = with(list1) {
        joinToString(",")          // this = list1，直接调用 joinToString
    }
    println(csv) // 1,2,3
 
    // === run: 接收者是调用对象，返回 Lambda 结果 ===
    // 签名: public inline fun <T, R> T.run(block: T.() -> R): R
    val upper = "hello".run {
        uppercase()                // this = "hello"
    }
    println(upper) // HELLO
}

// 一个通用的"构建并初始化"函数
// T: 要构建的类型；block 是以 T 为接收者的 Lambda
inline fun <T> T.configure(block: T.() -> Unit): T {
    this.block()                   // 在当前对象上执行配置 Lambda
    return this                    // 返回配置后的对象（链式调用）
}
 
// 一个通用的"创建-配置-转换"函数
// T: 接收者类型；R: 返回类型
inline fun <T, R> T.transform(block: T.() -> R): R {
    return this.block()            // 在当前对象上执行 Lambda 并返回结果
}
 
data class Server(
    var host: String = "",         // 服务器主机名
    var port: Int = 0,             // 端口号
    var ssl: Boolean = false       // 是否启用 SSL
)
 
fun main() {
    // 泛型接收者让同一个函数适用于任何类型
    val server = Server().configure {
        host = "kotlin.org"        // this: Server
        port = 443
        ssl = true
    }
    println(server) // Server(host=kotlin.org, port=443, ssl=true)
 
    // transform 将 Server 转换为一个描述字符串
    val desc = server.transform {
        "Server at $host:$port (SSL: $ssl)" // this: Server，返回 String
    }
    println(desc) // Server at kotlin.org:443 (SSL: true)
}

fun main() {
    // 带接收者的 Lambda 类型
    val receiverLambda: StringBuilder.() -> Unit = {
        append("Hello")           // this = StringBuilder
    }
 
    // 普通 Lambda 类型（参数形式）
    val normalLambda: (StringBuilder) -> Unit = {
        it.append("Hello")        // it = StringBuilder
    }
 
    // ✅ 带接收者的 Lambda 可以赋值给普通 Lambda 变量
    val asNormal: (StringBuilder) -> Unit = receiverLambda
 
    // ✅ 调用时，接收者变成了第一个参数
    val sb = StringBuilder()
    asNormal(sb)                   // 等价于 sb.receiverLambda()
    println(sb) // Hello
 
    // ⚠️ 反方向：普通 Lambda 也可以赋值给带接收者类型的变量
    val asReceiver: StringBuilder.() -> Unit = normalLambda
    val sb2 = StringBuilder()
    sb2.asReceiver()               // 等价于 normalLambda(sb2)
    println(sb2) // Hello
}

// 编译器视角的等价转换：
//
// 带接收者的 Lambda:
//   StringBuilder.() -> Unit
//   ┌─────────────────────────────┐
//   │  this: StringBuilder ──────►│ append("Hello")
//   │  (隐式参数，通过 this 访问) │
//   └─────────────────────────────┘
//
// 普通 Lambda:
//   (StringBuilder) -> Unit
//   ┌─────────────────────────────┐
//   │  it: StringBuilder ────────►│ it.append("Hello")
//   │  (显式参数，通过 it 访问)   │
//   └─────────────────────────────┘
//
// 本质区别仅在于：this（隐式）vs it（显式）
// 编译后的 JVM 字节码中，两者生成相同的方法签名：
//   invoke(StringBuilder): void

// JSON 值的密封接口
sealed interface JsonValue {
    fun toJson(): String           // 每种 JSON 类型都能序列化为字符串
}
 
// JSON 对象 {"key": value, ...}
class JsonObject : JsonValue {
    // 存储键值对，保持插入顺序
    private val entries = linkedMapOf<String, JsonValue>()
 
    // DSL 方法：使用 to 中缀函数风格添加字符串值
    fun string(key: String, value: String) {
        entries[key] = JsonString(value) // 将字符串值包装后存入
    }
 
    // DSL 方法：添加数字值
    fun number(key: String, value: Number) {
        entries[key] = JsonNumber(value) // 将数字值包装后存入
    }
 
    // DSL 方法：嵌套对象，参数是带接收者的 Lambda！
    fun obj(key: String, init: JsonObject.() -> Unit) {
        val child = JsonObject()   // 创建子对象
        child.init()               // 在子对象上执行 Lambda（this = child）
        entries[key] = child       // 将子对象存入当前对象
    }
 
    // 序列化为 JSON 字符串
    override fun toJson(): String {
        return entries.entries.joinToString(", ", "{", "}") { (k, v) ->
            "\"$k\": ${v.toJson()}" // 每个键值对格式化
        }
    }
}
 
// JSON 字符串值 "..."
class JsonString(private val value: String) : JsonValue {
    override fun toJson() = "\"$value\""  // 加上双引号
}
 
// JSON 数字值
class JsonNumber(private val value: Number) : JsonValue {
    override fun toJson() = value.toString() // 直接转字符串
}
 
// 顶层 DSL 入口函数
fun json(init: JsonObject.() -> Unit): JsonObject {
    val root = JsonObject()        // 创建根 JSON 对象
    root.init()                    // 执行配置 Lambda（this = root）
    return root                    // 返回配置好的对象
}
 
fun main() {
    // 使用 DSL 构建 JSON —— 看起来就像在写 JSON 本身！
    val result = json {
        string("name", "Kotlin")           // this: JsonObject (root)
        number("version", 2.0)
        obj("features") {                  // this: JsonObject (child)
            string("paradigm", "multi")    // 在子对象中操作
            number("year", 2011)
            obj("platforms") {             // this: JsonObject (grandchild)
                string("primary", "JVM")   // 三层嵌套，每层 this 不同
                string("secondary", "JS")
            }
        }
    }
    println(result.toJson())
    // {"name": "Kotlin", "version": 2.0, "features": {"paradigm": "multi", "year": 2011, "platforms": {"primary": "JVM", "secondary": "JS"}}}
}

class A {
    fun greet() = "Hello from A"
}
 
class B {
    fun greet() = "Hello from B"
}
 
fun buildA(block: A.() -> Unit) = A().apply(block)
fun A.nested(block: B.() -> Unit) = B().apply(block)
 
fun main() {
    buildA {
        nested {
            println(greet())
            println(this@buildA.greet())
        }
    }
}

// ========== 定义三个简化的 HTML 构建器类 ==========
 
// 最外层：<html> 标签的构建器
class HTML {
    // 子元素列表，存放所有子节点的字符串表示
    private val children = mutableListOf<String>()
 
    // 嵌套 <head> 标签：接收一个以 HEAD 为接收者的 Lambda
    fun head(block: HEAD.() -> Unit) {
        val head = HEAD()          // 创建 HEAD 实例
        head.block()               // 在 HEAD 作用域中执行 Lambda
        children += head.render()  // 将渲染结果加入子元素
    }
 
    // 嵌套 <body> 标签：接收一个以 BODY 为接收者的 Lambda
    fun body(block: BODY.() -> Unit) {
        val body = BODY()          // 创建 BODY 实例
        body.block()               // 在 BODY 作用域中执行 Lambda
        children += body.render()  // 将渲染结果加入子元素
    }
 
    // 渲染当前标签及所有子元素
    fun render(): String = "<html>\n${children.joinToString("\n")}\n</html>"
}
 
// <head> 标签的构建器
class HEAD {
    private val children = mutableListOf<String>()
 
    // <title> 是 head 的合法子元素
    fun title(text: String) {
        children += "  <title>$text</title>"
    }
 
    fun render(): String = "<head>\n${children.joinToString("\n")}\n</head>"
}
 
// <body> 标签的构建器
class BODY {
    private val children = mutableListOf<String>()
 
    // <h1> 是 body 的合法子元素
    fun h1(text: String) {
        children += "  <h1>$text</h1>"
    }
 
    // <p> 是 body 的合法子元素
    fun p(text: String) {
        children += "  <p>$text</p>"
    }
 
    fun render(): String = "<body>\n${children.joinToString("\n")}\n</body>"
}
 
// ========== 顶层入口函数 ==========
fun html(block: HTML.() -> Unit): HTML {
    val html = HTML()   // 创建根节点
    html.block()        // 执行用户传入的 DSL Lambda
    return html         // 返回构建好的树
}

fun main() {
    val page = html {                   // this: HTML
        head {                          // this: HEAD
            title("My Page")           // ✅ 正确：HEAD.title()
        }
        body {                          // this: BODY
            h1("Hello")                // ✅ 正确：BODY.h1()
 
            // ⚠️ 危险！在 body{} 里面调用了 head{} ——
            // 编译器不会报错，因为外层 HTML 的 this 仍然可见！
            head {                      // 实际调用的是 HTML.head()
                title("Injected!")      // 语义完全错误
            }
        }
    }
    println(page.render())
}

// ========== 第一步：定义你的 DSL 标记注解 ==========
@DslMarker                          // 元注解：声明这是一个 DSL 作用域标记
@Target(AnnotationTarget.CLASS)     // 只允许标注在类上
annotation class HtmlDslMarker       // 自定义注解名，语义上表示 "HTML DSL 家族"
 
// ========== 第二步：将注解标记到所有 DSL 构建器类上 ==========
@HtmlDslMarker                      // 标记：HTML 属于 HtmlDsl 作用域族
class HTML { /* ... 同上 ... */ }
 
@HtmlDslMarker                      // 标记：HEAD 属于 HtmlDsl 作用域族
class HEAD { /* ... 同上 ... */ }
 
@HtmlDslMarker                      // 标记：BODY 属于 HtmlDsl 作用域族
class BODY { /* ... 同上 ... */ }
 
// ========== 第三步：无需修改其他代码，编译器自动生效 ==========

fun main() {
    html {                              // this: HTML
        body {                          // this: BODY
            h1("Hello")                // ✅ BODY.h1() — 当前作用域，允许
 
            // ❌ 编译错误！
            // 'fun head(block: HEAD.() -> Unit): Unit' can't be called
            // in this context by implicit receiver.
            // Use the explicit receiver if necessary: this@html.head { }
            head {
                title("Injected!")
            }
        }
    }
}

// 两个完全独立的 DSL 标记
@DslMarker annotation class HtmlDsl    // HTML DSL 家族
@DslMarker annotation class CssDsl     // CSS DSL 家族
 
@HtmlDsl class BODY { /* ... */ }
@CssDsl  class StyleBuilder { /* ... */ }
 
// 如果 body 内嵌套了 style Lambda:
// BODY 和 StyleBuilder 属于不同 DslMarker 族，
// 因此 StyleBuilder 内部仍可隐式访问 BODY 的成员！

// ======================== DSL Marker 定义 ========================
@DslMarker
@Target(AnnotationTarget.CLASS)         // 限定只能注解在类上
annotation class HtmlTagMarker           // 所有 HTML 标签构建器的统一标记
 
// ======================== 标签基类 ========================
@HtmlTagMarker                           // 基类标记后，所有子类自动继承此标记
open class Tag(val name: String) {
    // 子节点列表
    protected val children = mutableListOf<Tag>()
    // 文本内容（叶子节点使用）
    var textContent: String = ""
 
    // 渲染当前标签树为 HTML 字符串（递归）
    open fun render(indent: Int = 0): String {
        val pad = "  ".repeat(indent)               // 缩进控制
        return if (children.isEmpty() && textContent.isNotEmpty()) {
            "$pad<$name>$textContent</$name>"        // 叶子节点：单行输出
        } else {
            buildString {
                appendLine("$pad<$name>")            // 开标签
                children.forEach {                   // 递归渲染子节点
                    appendLine(it.render(indent + 1))
                }
                append("$pad</$name>")               // 闭标签
            }
        }
    }
}
 
// ======================== 具体标签类 ========================
class HTML : Tag("html") {
    // 只允许在 <html> 内调用 head {}
    fun head(block: HEAD.() -> Unit) {
        val head = HEAD()                           // 实例化 HEAD 构建器
        head.block()                                // 在 HEAD 作用域中执行用户代码
        children += head                            // 将 HEAD 挂载为子节点
    }
 
    // 只允许在 <html> 内调用 body {}
    fun body(block: BODY.() -> Unit) {
        val body = BODY()                           // 实例化 BODY 构建器
        body.block()                                // 在 BODY 作用域中执行用户代码
        children += body                            // 将 BODY 挂载为子节点
    }
}
 
class HEAD : Tag("head") {
    // <title> 是 <head> 的合法子元素
    fun title(text: String) {
        val t = Tag("title")                        // 创建 <title> 节点
        t.textContent = text                        // 设置文本内容
        children += t                               // 挂载
    }
 
    // <meta> 标签（简化演示）
    fun meta(charset: String) {
        val m = Tag("meta charset=\"$charset\"")    // 简化处理
        children += m
    }
}
 
class BODY : Tag("body") {
    // <h1> 标签
    fun h1(text: String) {
        val h = Tag("h1")
        h.textContent = text
        children += h
    }
 
    // <p> 标签
    fun p(text: String) {
        val p = Tag("p")
        p.textContent = text
        children += p
    }
 
    // <div> 可嵌套子元素
    fun div(block: BODY.() -> Unit) {
        val div = BODY()                            // 复用 BODY 的能力（简化）
        div.block()
        // 偷换标签名用于演示目的
        children += object : Tag("div") {
            init { this.children.addAll(div.children) }
        }
    }
}
 
// ======================== 顶层入口 ========================
fun html(block: HTML.() -> Unit): HTML {
    return HTML().apply(block)                      // 创建根节点并执行 DSL
}
 
// ======================== 使用示例 ========================
fun main() {
    val document = html {                           // this: HTML
        head {                                      // this: HEAD
            title("Kotlin DSL Demo")
            meta("UTF-8")
 
            // ❌ 编译错误！head {} 内不能隐式调用 body {}
            // body { h1("Oops") }
        }
        body {                                      // this: BODY
            h1("Welcome to Kotlin DSL")
            p("This is a type-safe builder example.")
 
            div {                                   // this: BODY (div 复用)
                p("Inside a div")
 
                // ❌ 编译错误！div {} 内不能隐式调用 head {}
                // head { title("Nope") }
 
                // ✅ 如果确实需要，必须显式限定：
                // this@html.head { title("Explicitly!") }
            }
        }
    }
 
    println(document.render())
}

<html>
  <head>
    <title>Kotlin DSL Demo</title>
    <meta charset="UTF-8"><meta charset="UTF-8">
  </head>
  <body>
    <h1>Welcome to Kotlin DSL</h1>
    <p>This is a type-safe builder example.</p>
    <div>
      <p>Inside a div</p>
    </div>
  </body>
</html>

// ======================== 两套独立的 DslMarker ========================
@DslMarker annotation class HtmlDsl    // HTML 标签族
@DslMarker annotation class CssDsl     // CSS 样式族
 
// ======================== HTML 构建器 ========================
@HtmlDsl
class BodyBuilder {
    private val elements = mutableListOf<String>()
 
    // 在 body 中可以嵌套 style 块（跨族）
    fun style(block: StyleBuilder.() -> Unit) {
        val sb = StyleBuilder()          // 创建 CSS 族构建器
        sb.block()                       // 在 CSS 作用域中执行
        elements += "<style>${sb.build()}</style>"
    }
 
    fun p(text: String) {
        elements += "<p>$text</p>"
    }
 
    fun build(): String = elements.joinToString("\n")
}
 
// ======================== CSS 构建器 ========================
@CssDsl
class StyleBuilder {
    private val rules = mutableListOf<String>()
 
    // CSS 规则：选择器 + 属性块
    fun rule(selector: String, block: RuleBuilder.() -> Unit) {
        val rb = RuleBuilder()
        rb.block()
        rules += "$selector { ${rb.build()} }"
    }
 
    fun build(): String = rules.joinToString("\n")
}
 
@CssDsl
class RuleBuilder {
    private val props = mutableListOf<String>()
 
    // CSS 属性设置
    fun property(name: String, value: String) {
        props += "$name: $value;"
    }
 
    fun build(): String = props.joinToString(" ")
}
 
// ======================== 使用示例 ========================
fun main() {
    val body = BodyBuilder().apply {     // this: BodyBuilder (@HtmlDsl)
        p("Hello World")
 
        style {                          // this: StyleBuilder (@CssDsl)
            rule("body") {               // this: RuleBuilder  (@CssDsl)
                property("margin", "0")
                property("padding", "0")
 
                // ❌ 同族限制：RuleBuilder 内不能隐式调用 StyleBuilder.rule()
                // rule("h1") { ... }  // 编译错误！
 
                // ✅ 跨族穿透：RuleBuilder(@CssDsl) 内可以隐式访问 BodyBuilder(@HtmlDsl)
                // p("Accessible!")     // 这行能编译通过！（但语义不合理）
            }
        }
    }
    println(body.build())
}

// 所有构建器共用一个 Marker，彻底封堵跨族穿透
@DslMarker annotation class UnifiedDsl
 
@UnifiedDsl class BodyBuilder { /* ... */ }
@UnifiedDsl class StyleBuilder { /* ... */ }
@UnifiedDsl class RuleBuilder  { /* ... */ }

// RuleBuilder 同时属于两个族
@CssDsl
@HtmlDsl           // 额外标注，使其与 BodyBuilder 也互斥
class RuleBuilder { /* ... */ }

class InnerScope {
    // 当用户在内层尝试调用外层的 dangerousMethod 时
    // 编译器会报 ERROR 级别错误（而非警告）
    @Deprecated(
        message = "Cannot call dangerousMethod in InnerScope. Use explicit receiver.",
        level = DeprecationLevel.ERROR     // ERROR 级别 = 编译失败
    )
    fun dangerousMethod() {
        // 空实现，永远不会被调用
        // 仅用于"覆盖"外层同名函数的解析
    }
}

html {                                  // 标签: html
    body {                              // 标签: body
        // ❌ 隐式调用被阻止
        // head { title("Nope") }
 
        // ✅ 显式限定：开发者明确知道自己在做什么
        this@html.head {
            title("I know what I'm doing")
        }
    }
}

// 只暴露 body 层面允许的操作
interface BodyScope {
    fun h1(text: String)               // ✅ 允许
    fun p(text: String)                // ✅ 允许
    fun div(block: BodyScope.() -> Unit) // ✅ 允许嵌套 div
    // head() 根本不在此接口中，连"误调用"的可能都没有
}
 
// 内部实现类对外不可见
internal class BodyScopeImpl : BodyScope {
    override fun h1(text: String) { /* ... */ }
    override fun p(text: String) { /* ... */ }
    override fun div(block: BodyScope.() -> Unit) { /* ... */ }
}

// Compose 框架内部定义（简化）
@DslMarker
annotation class LayoutScopeMarker
 
@LayoutScopeMarker
interface ColumnScope {
    // Column 特有的 Modifier 扩展
    fun Modifier.weight(weight: Float): Modifier
    fun Modifier.align(alignment: Alignment.Horizontal): Modifier
}
 
@LayoutScopeMarker
interface RowScope {
    // Row 特有的 Modifier 扩展
    fun Modifier.weight(weight: Float): Modifier
    fun Modifier.align(alignment: Alignment.CenterVertically): Modifier
}

// 用户代码
Column {                                // this: ColumnScope
    Text("Hello")
 
    Row {                               // this: RowScope
        Text("World")
 
        // ❌ 编译错误！不能在 Row 中使用 ColumnScope 的 align
        // Modifier.align(Alignment.CenterHorizontally)
 
        // ✅ 只能使用 RowScope 的 align
        Text(
            text = "Aligned",
            modifier = Modifier.align(Alignment.CenterVertically)
        )
    }
}

@DslMarker annotation class MyDsl
 
@MyDsl class Outer {
    fun outerFun() = println("outer")
}
 
@MyDsl class Inner {
    fun innerFun() = println("inner")
}
 
fun buildOuter(block: Outer.() -> Unit) = Outer().block()
 
fun Outer.nested(block: Inner.() -> Unit) = Inner().block()
 
fun main() {
    buildOuter {          // this: Outer
        outerFun()        // Line A
        nested {          // this: Inner
            innerFun()    // Line B
            outerFun()    // Line C
            this@buildOuter.outerFun() // Line D
        }
    }
}

// 目标：用 Kotlin DSL 生成 HTML，而不是手动拼接字符串
val page = html {
    head {
        title("Kotlin DSL 教程")
    }
    body {
        h1("类型安全构建器")
        p("这是一个用 Kotlin DSL 生成的段落。")
        ul {
            li("第一项")
            li("第二项")
            li("第三项")
        }
    }
}

// ====== 所有 HTML 元素的抽象基类 ======
 
// 用 @DslMarker 标注，防止外层作用域泄露到内层
@DslMarker                              // 声明一个 DSL 标记注解
annotation class HtmlDsl                // 所有 HTML 构建器类都会标注它
 
@HtmlDsl                                // 将标记应用到基类
abstract class HtmlElement {            // HTML 元素的抽象基类
    // 子元素列表，所有嵌套标签都会被添加到这里
    protected val children = mutableListOf<HtmlElement>()
 
    // 将子元素添加到当前节点
    fun addChild(child: HtmlElement) {  // 统一的子节点注册方法
        children.add(child)             // 加入子列表
    }
 
    // 每个具体标签必须实现自己的渲染逻辑
    abstract fun render(indent: String = ""): String  // 缩进渲染为字符串
}

// ====== 文本节点 —— 代表纯文本内容 ======
class TextElement(                      // 纯文本节点，不含子元素
    private val text: String            // 持有文本内容
) : HtmlElement() {
    override fun render(indent: String) // 渲染时直接输出文本
        = "$indent$text\n"              // 加上缩进和换行
}
 
// ====== 通用标签节点 —— 含标签名、属性和子元素 ======
@HtmlDsl                                // 标记为 DSL 作用域
open class Tag(                         // 通用 HTML 标签
    private val name: String            // 标签名，如 "div", "p", "ul"
) : HtmlElement() {
 
    // 标签属性表，如 class="xxx", id="yyy"
    private val attributes = mutableMapOf<String, String>()
 
    // DSL 内设置属性的方法
    fun attribute(key: String, value: String) {  // 添加 HTML 属性
        attributes[key] = value                   // 存入属性表
    }
 
    // 渲染：开标签 + 子元素递归渲染 + 闭标签
    override fun render(indent: String): String {
        val builder = StringBuilder()              // 创建字符串构建器
        // 拼接属性字符串，如 class="container" id="main"
        val attrStr = if (attributes.isNotEmpty()) // 判断是否有属性
            attributes.entries.joinToString(" ") { // 遍历所有属性
                "${it.key}=\"${it.value}\""         // 拼接为 key="value"
            }.let { " $it" }                        // 前面加空格
        else ""                                     // 无属性则为空串
 
        builder.append("$indent<$name$attrStr>\n")  // 输出开标签
        children.forEach { child ->                  // 遍历所有子元素
            builder.append(child.render("$indent  ")) // 递归渲染，增加缩进
        }
        builder.append("$indent</$name>\n")          // 输出闭标签
        return builder.toString()                     // 返回完整字符串
    }
}

// ====== HTML 根节点 —— 只允许 head{} 和 body{} ======
class Html : Tag("html") {                      // html 标签
    fun head(init: Head.() -> Unit) {            // 只在 html 内可调用 head
        val head = Head()                         // 创建 Head 节点
        head.init()                               // 在 Head 作用域内执行 lambda
        addChild(head)                            // 将 head 挂载为子节点
    }
 
    fun body(init: Body.() -> Unit) {            // 只在 html 内可调用 body
        val body = Body()                         // 创建 Body 节点
        body.init()                               // 在 Body 作用域内执行 lambda
        addChild(body)                            // 将 body 挂载为子节点
    }
}
 
// ====== Head 节点 —— 只允许 title() ======
class Head : Tag("head") {                       // head 标签
    fun title(text: String) {                     // 只允许在 head 内调用 title
        val titleTag = Tag("title")               // 创建 title 标签
        titleTag.addChild(TextElement(text))      // 给 title 添加文本子节点
        addChild(titleTag)                        // 将 title 挂载到 head
    }
}
 
// ====== Body 节点 —— 允许 h1, p, div, ul 等 ======
class Body : Tag("body") {                       // body 标签
    fun h1(text: String) {                        // 在 body 内可调用 h1
        val tag = Tag("h1")                       // 创建 h1 标签
        tag.addChild(TextElement(text))           // 添加文本内容
        addChild(tag)                             // 挂载到 body
    }
 
    fun p(text: String) {                         // 在 body 内可调用 p
        val tag = Tag("p")                        // 创建 p 标签
        tag.addChild(TextElement(text))           // 添加文本内容
        addChild(tag)                             // 挂载到 body
    }
 
    fun ul(init: Ul.() -> Unit) {                 // 在 body 内可调用 ul
        val ul = Ul()                             // 创建 Ul 节点
        ul.init()                                 // 在 Ul 作用域内执行
        addChild(ul)                              // 挂载到 body
    }
 
    fun div(init: Body.() -> Unit) {              // div 复用 Body 的作用域
        val div = Tag("div")                      // 创建 div 标签
        val body = Body()                         // 借用 Body 作用域
        body.init()                               // 执行 lambda
        body.children.forEach { div.addChild(it) }// 把子节点转移到 div
        addChild(div)                             // 挂载 div
    }
}
 
// ====== Ul 节点 —— 只允许 li() ======
class Ul : Tag("ul") {                           // ul 标签
    fun li(text: String) {                        // 只允许在 ul 内调用 li
        val li = Tag("li")                        // 创建 li 标签
        li.addChild(TextElement(text))            // 添加文本
        addChild(li)                              // 挂载到 ul
    }
}

// ====== DSL 入口 —— 全局函数 ======
fun html(init: Html.() -> Unit): Html {  // 顶层构建函数
    val html = Html()                     // 创建根节点
    html.init()                           // 在 Html 作用域内执行 lambda
    return html                           // 返回构建完成的 HTML 树
}

html {
    head {
        title("OK")     // ✅ Head 作用域内合法
        // li("Oops")   // ❌ 编译错误！Head 中没有 li() 方法
    }
    body {
        h1("标题")       // ✅ Body 作用域内合法
        ul {
            li("项目")   // ✅ Ul 作用域内合法
            // h1("X")   // ❌ 编译错误！Ul 中没有 h1() 方法
        }
        // li("脱离")    // ❌ 编译错误！Body 中没有 li() 方法
    }
}

// ====== 列类型 —— 用泛型锁定列的数据类型 ======
class Column<T>(                             // 泛型列，T 为列的数据类型
    val name: String,                        // 列名
    val table: Table                         // 所属表的引用
) {
    // 生成 "表名.列名" 格式的 SQL 片段
    fun fullName(): String =                 // 返回全限定列名
        "${table.tableName}.$name"           // 如 "users.id"
}
 
// ====== 表基类 —— 每个数据库表继承它 ======
abstract class Table(                        // 抽象表定义
    val tableName: String                    // 表名
) {
    // 已注册的列列表
    val columns = mutableListOf<Column<*>>() // 保存所有列定义
 
    // DSL 方法：声明一个整型列
    fun integer(name: String): Column<Int> { // 定义 Int 类型的列
        val col = Column<Int>(name, this)    // 创建列对象
        columns.add(col)                     // 注册到表
        return col                           // 返回列引用
    }
 
    // DSL 方法：声明一个字符串列
    fun varchar(                             // 定义 String 类型的列
        name: String,                        // 列名
        length: Int = 255                    // 最大长度，默认 255
    ): Column<String> {
        val col = Column<String>(name, this) // 创建列对象
        columns.add(col)                     // 注册到表
        return col                           // 返回列引用
    }
}
 
// ====== 具体表定义 —— 使用 object 单例 ======
object Users : Table("users") {              // users 表
    val id = integer("id")                   // id 列，Int 类型
    val name = varchar("name", 50)           // name 列，String 类型
    val email = varchar("email", 100)        // email 列，String 类型
}
 
object Orders : Table("orders") {            // orders 表
    val id = integer("id")                   // 订单 id
    val userId = integer("user_id")          // 外键，关联 users.id
    val amount = integer("amount")           // 金额
}

// ====== WHERE 条件表达式 ======
sealed class Expression {                     // 所有条件表达式的基类
    abstract fun toSql(): String              // 生成 SQL 片段
 
    // 条件间用 AND 连接
    infix fun and(other: Expression):         // 中缀函数实现 AND
        Expression = AndExpression(this, other)
 
    // 条件间用 OR 连接
    infix fun or(other: Expression):          // 中缀函数实现 OR
        Expression = OrExpression(this, other)
}
 
// "列 = 值" 表达式
class EqExpression(                           // 等值比较
    private val column: Column<*>,            // 左侧列
    private val value: Any                    // 右侧值
) : Expression() {
    override fun toSql(): String =            // 生成如 users.id = 1
        "${column.fullName()} = ${formatValue(value)}"
 
    private fun formatValue(v: Any) = when(v) { // 格式化值
        is String -> "'$v'"                      // 字符串加引号
        else -> v.toString()                     // 其他类型直接转换
    }
}
 
// AND 组合表达式
class AndExpression(                          // AND 连接
    private val left: Expression,             // 左表达式
    private val right: Expression             // 右表达式
) : Expression() {
    override fun toSql() =                    // 生成 (left AND right)
        "(${left.toSql()} AND ${right.toSql()})"
}
 
// OR 组合表达式
class OrExpression(                           // OR 连接
    private val left: Expression,
    private val right: Expression
) : Expression() {
    override fun toSql() =                    // 生成 (left OR right)
        "(${left.toSql()} OR ${right.toSql()})"
}
 
// ====== 列的扩展函数 —— DSL 语法糖 ======
infix fun <T> Column<T>.eq(value: T):        // 类型安全的等值比较
    Expression = EqExpression(this, value as Any)
// 注意泛型 T：Column<Int>.eq() 只接受 Int，Column<String>.eq() 只接受 String

// ====== 查询构建器 ======
@DslMarker
annotation class SqlDsl                       // SQL DSL 作用域标记
 
@SqlDsl
class Query {                                 // 查询构建上下文
    private val selectedColumns =             // SELECT 的列
        mutableListOf<Column<*>>()
    private var fromTable: Table? = null       // FROM 的表
    private var whereExpr: Expression? = null  // WHERE 条件
 
    // SELECT 子句
    fun select(vararg cols: Column<*>) {       // 选择列
        selectedColumns.addAll(cols)            // 添加到列表
    }
 
    // FROM 子句
    fun from(table: Table) {                   // 指定表
        fromTable = table                       // 记录表引用
    }
 
    // WHERE 子句 —— 接收一个返回 Expression 的 Lambda
    fun where(condition: () -> Expression) {    // 条件构建
        whereExpr = condition()                 // 执行 Lambda 得到表达式
    }
 
    // 生成最终 SQL
    fun build(): String {                       // 构建 SQL 字符串
        val cols = if (selectedColumns.isEmpty()) "*"  // 无列则 SELECT *
            else selectedColumns.joinToString(", ")    // 逗号分隔列名
                { it.fullName() }
        val sql = StringBuilder("SELECT $cols")         // 拼接 SELECT
        fromTable?.let { sql.append(" FROM ${it.tableName}") }  // 拼接 FROM
        whereExpr?.let { sql.append(" WHERE ${it.toSql()}") }   // 拼接 WHERE
        return sql.toString()                            // 返回完整 SQL
    }
}
 
// ====== 顶层 DSL 入口 ======
fun query(init: Query.() -> Unit): String {    // DSL 入口函数
    val q = Query()                             // 创建查询构建器
    q.init()                                    // 在 Query 作用域内执行
    return q.build()                            // 构建并返回 SQL
}

fun main() {
    // 简单查询
    val sql1 = query {                         // 开始构建查询
        select(Users.name, Users.email)        // SELECT users.name, users.email
        from(Users)                            // FROM users
        where { Users.id eq 1 }               // WHERE users.id = 1
    }
    println(sql1)
    // 输出: SELECT users.name, users.email FROM users WHERE users.id = 1
 
    // 复合条件查询
    val sql2 = query {                         // 开始构建查询
        select(Users.name)                     // SELECT users.name
        from(Users)                            // FROM users
        where {                                // WHERE 复合条件
            (Users.name eq "Alice") and        // name = 'Alice'
            (Users.email eq "a@b.com")         // AND email = 'a@b.com'
        }
    }
    println(sql2)
    // 输出: SELECT users.name FROM users
    //       WHERE (users.name = 'Alice' AND users.email = 'a@b.com')
 
    // ❌ 编译错误示例（取消注释会报错）：
    // where { Users.id eq "hello" }
    // 原因：Users.id 是 Column<Int>，eq 要求参数类型为 Int，传 String 不匹配
}

// 目标：像写配置文件一样写 Kotlin 代码
val config = appConfig {
    server {
        host = "0.0.0.0"
        port = 8080
        ssl {
            enabled = true
            certPath = "/etc/ssl/cert.pem"
        }
    }
    database {
        url = "jdbc:postgresql://localhost:5432/mydb"
        username = "admin"
        password = "secret"
        pool {
            maxSize = 20
            minIdle = 5
            timeout = 30_000L
        }
    }
    logging {
        level = LogLevel.INFO
        format = "JSON"
    }
}

// ====== DSL 标记 ======
@DslMarker
annotation class ConfigDsl                      // 配置 DSL 作用域标记
 
// ====== 日志级别枚举 ======
enum class LogLevel {                           // 日志级别定义
    DEBUG, INFO, WARN, ERROR                    // 四个级别
}
 
// ====== SSL 配置 ======
@ConfigDsl
class SslConfig {                               // SSL 子配置
    var enabled: Boolean = false                 // 是否启用 SSL
    var certPath: String = ""                    // 证书路径
    var keyPath: String = ""                     // 密钥路径
 
    override fun toString() =                   // 方便打印
        "SSL(enabled=$enabled, cert=$certPath)"
}
 
// ====== 服务器配置 ======
@ConfigDsl
class ServerConfig {                            // 服务器配置
    var host: String = "localhost"               // 主机地址，默认 localhost
    var port: Int = 8080                         // 端口号，默认 8080
    private var sslConfig = SslConfig()          // 内嵌 SSL 配置
 
    // 嵌套 DSL：在 server {} 内部可以调用 ssl {}
    fun ssl(init: SslConfig.() -> Unit) {        // SSL 配置入口
        sslConfig.apply(init)                    // 在 SslConfig 作用域内执行
    }
 
    fun getSsl() = sslConfig                     // 获取 SSL 配置
 
    override fun toString() =
        "Server(host=$host, port=$port, ssl=$sslConfig)"
}
 
// ====== 连接池配置 ======
@ConfigDsl
class PoolConfig {                              // 连接池配置
    var maxSize: Int = 10                        // 最大连接数
    var minIdle: Int = 2                         // 最小空闲连接
    var timeout: Long = 10_000L                  // 超时时间（毫秒）
 
    override fun toString() =
        "Pool(max=$maxSize, minIdle=$minIdle, timeout=${timeout}ms)"
}
 
// ====== 数据库配置 ======
@ConfigDsl
class DatabaseConfig {                          // 数据库配置
    var url: String = ""                         // JDBC URL
    var username: String = ""                    // 用户名
    var password: String = ""                    // 密码
    private var poolConfig = PoolConfig()        // 内嵌连接池配置
 
    // 嵌套 DSL：在 database {} 内部可以调用 pool {}
    fun pool(init: PoolConfig.() -> Unit) {      // 连接池配置入口
        poolConfig.apply(init)                   // 在 PoolConfig 作用域内执行
    }
 
    fun getPool() = poolConfig
 
    override fun toString() =
        "Database(url=$url, user=$username, pool=$poolConfig)"
}
 
// ====== 日志配置 ======
@ConfigDsl
class LoggingConfig {                           // 日志配置
    var level: LogLevel = LogLevel.INFO          // 日志级别
    var format: String = "TEXT"                  // 输出格式
 
    override fun toString() =
        "Logging(level=$level, format=$format)"
}
 
// ====== 应用总配置 ======
@ConfigDsl
class AppConfig {                               // 应用程序总配置
    private var serverConfig = ServerConfig()    // 服务器配置
    private var databaseConfig = DatabaseConfig()// 数据库配置
    private var loggingConfig = LoggingConfig()  // 日志配置
 
    fun server(init: ServerConfig.() -> Unit) {  // server 配置入口
        serverConfig.apply(init)                 // 在 ServerConfig 作用域执行
    }
 
    fun database(init: DatabaseConfig.() -> Unit) { // database 配置入口
        databaseConfig.apply(init)                    // 在 DatabaseConfig 作用域执行
    }
 
    fun logging(init: LoggingConfig.() -> Unit) { // logging 配置入口
        loggingConfig.apply(init)                   // 在 LoggingConfig 作用域执行
    }
 
    // 获取各子配置
    fun getServer() = serverConfig
    fun getDatabase() = databaseConfig
    fun getLogging() = loggingConfig
 
    override fun toString() = """
        |AppConfig:
        |  $serverConfig
        |  $databaseConfig
        |  $loggingConfig
    """.trimMargin()
}
 
// ====== 顶层 DSL 入口 ======
fun appConfig(init: AppConfig.() -> Unit): AppConfig { // 入口函数
    return AppConfig().apply(init)                       // 创建并初始化
}