plugins {
    kotlin("multiplatform")
    id("com.google.devtools.ksp")
}

kotlin {
    jvm()
    // other targets…
}

dependencies {
    implementation("top.ltfan.dslutilities:dsl-utilities:<version>")
    add("kspJvm", "top.ltfan.dslutilities:dsl-utilities-ksp:<version>")
}

object NonBlankValidator : DslValidator<String> {
    override fun validate(value: String) = value.isNotBlank()
}

object UpperCaseMapper : DslMapper<String, String> {
    override fun toStored(value: String) = value.lowercase()
    override fun toValue(stored: String) = stored.uppercase()
}

@DslBuilder
interface PersonDsl {
    // `val` properties are required values; the compiler enforces their
    // presence at every call site of the generated build function.
    val name: String

    @DslValue(validator = NonBlankValidator::class, message = "The title must not be blank.")
    val title: String

    // `var` properties are set inside the DSL block. Nullable properties
    // are optional and default to null.
    @DslValue
    var nickname: String?

    // `initial` carries a compile-time constant; `mapper` transforms values
    // between the declared type and the stored representation; `validator`
    // rejects values in the generated setter.
    @DslValue(initial = "default", mapper = UpperCaseMapper::class)
    var prepared: String

    // List properties are mutated inside the DSL block; their elements are
    // validated when the value is built.
    @DslList(validator = NonBlankValidator::class, message = "The tags must not be blank.")
    var tags: MutableList<String>
}

val person = buildPerson(name = "LTFan", title = "Author") {
    nickname = "Fan"
    prepared = "Prepared"
    tags.add("kotlin")
}

person.name                 // "LTFan"
person.prepared             // "PREPARED"
person.tags                 // read-only list
// person.nickname = "x"    // compile error: the result exposes no setters

sealed interface Event

@DslBuilder(supertype = Event::class)
interface TransientEventDsl {
    @DslValue
    var intensity: Float?
}

@DslBuilder(supertype = Event::class)
interface ContinuousEventDsl {
    val at: Int

    @DslValue
    var label: String?
}

@DslBuilder
interface EventsDsl {
    // Generates `event`-style element functions on the block receiver:
    //   fun transientEvent(block: TransientEventDsl.() -> Unit = {})
    //   val transientEvent: Unit          // shorthand for the default child
    //   fun continuousEvent(at: Int, block: ContinuousEventDsl.() -> Unit = {})
    @DslList(children = [TransientEventDsl::class, ContinuousEventDsl::class])
    var events: MutableList<Event>
}

@DslBuilder
interface PatternDsl {
    // Generates the function body, which builds the child and stores it.
    @DslChild
    fun events(block: EventsDsl.() -> Unit = {})
}

val pattern = buildPattern {
    events {
        transientEvent { intensity = 0.8f }
        transientEvent
        continuousEvent(at = 20) { label = "low" }
    }
}

kotlin {
    sourceSets {
        commonMain {
            kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
        }
    }
}

tasks.configureEach {
    if (name.startsWith("ksp") && name != "kspCommonMainKotlinMetadata") {
        dependsOn("kspCommonMainKotlinMetadata")
    }
}
tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>().configureEach {
    if (name != "kspCommonMainKotlinMetadata") {
        dependsOn("kspCommonMainKotlinMetadata")
    }
}
tasks.withType<Jar>().configureEach {
    if (name.contains("sourcesJar", ignoreCase = true)) {
        dependsOn("kspCommonMainKotlinMetadata")
    }
}

dependencies {
    add("kspCommonMainMetadata", "top.ltfan.dslutilities:dsl-utilities-ksp:<version>")
}