val form = FormikController(
    FormikConfig(
        initialValues = mapOf<String, Any?>("email" to "", "password" to ""),
        validate = { v -> buildErrors {
            if ((v["email"] as String).isBlank())          put("email", "Required")
            if ((v["password"] as String).length < 8)      put("password", "Too short")
        }},
        onSubmit = { values, _ ->
            api.login(values["email"] as String, values["password"] as String)
        },
    )
)

// setFieldValue / setFieldTouched / submit are suspend — call them from a coroutine
// (or use the fire-and-forget form.handleSubmit() outside one):
scope.launch {
    form.setFieldValue("email", "user@example.com")
    form.setFieldTouched("email", true)
    form.submit()
}

plugins {
    kotlin("jvm") version "2.0.21"                              // or kotlin("multiplatform") / kotlin("android")

    // Only if you use @FormValues — the ksp(...) dep below requires this plugin.
    id("com.google.devtools.ksp") version "2.0.21-1.0.27"

    // Only if you use the Compose adapter. For pure Android Compose, the Android Compose
    // plugin works too; the JetBrains one is what enables KMP shared composables.
    id("org.jetbrains.compose") version "1.7.3"
    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21"
}

repositories {
    mavenCentral()
    google()
}

dependencies {
    implementation("io.github.apdelrahman1911:kformik:1.5.0")

    // Optional
    implementation("io.github.apdelrahman1911:kformik-compose:1.5.0")  // Compose Multiplatform adapter

    // KSP processor — needs BOTH compileOnly (for @FormValues import) and ksp (to run the processor)
    compileOnly("io.github.apdelrahman1911:kformik-ksp:1.5.0")
    ksp("io.github.apdelrahman1911:kformik-ksp:1.5.0")
}

// Style A — plain validate callback. Just Kotlin. Good when the logic doesn't fit a rule shape
// or you want fine-grained control over conditionals.
val formA = FormikController(FormikConfig(
    initialValues = mapOf("email" to "", "password" to ""),
    validate = { v -> buildErrors {
        if ((v["email"] as String).isBlank())     put("email", "Required")
        if ((v["password"] as String).length < 8) put("password", "Too short")
    }},
    onSubmit = { /* … */ },
))

// Style B — schema DSL. Same rules, declared field by field. Introspectable; rules are data.
val schema = formSchema<Map<String, Any?>> {
    field("email") {
        required()
    }
    field("password") {
        required()
        minLength(8)
    }
}
val formB = FormikController(FormikConfig(
    initialValues = mapOf("email" to "", "password" to ""),
    schemaValidator = schema,
    onSubmit = { /* … */ },
))

val schema = formSchema<Map<String, Any?>> {
    field("password") {
        required()
        minLength(8)
    }
    field("confirm") {
        required()
        // `v` is the current value at "confirm"; `all` is the whole form snapshot, so you can
        // compare to any other path. Return null to pass, a message to fail.
        custom("Doesn't match") { v, all -> if (v == all["password"]) null else "Doesn't match" }
    }
}

val schema = formSchema<Map<String, Any?>> {
    field("user.email")          { required(); email() }
    field("user.address.city")   { required() }
    field("tags[0]")             { minLength(3) }
}

val schema = formSchema<Map<String, Any?>>(failFast = false) {
    field("password") {
        required()
        minLength(8)
        custom("Must contain a digit") { v, _ -> if (v.toString().any(Char::isDigit)) null else "Must contain a digit" }
    }
}
// validateAllField suspends — call it from a coroutine or suspend function:
val errors = schema.validateAllField(values, "password")
// ["Required", "Too short", "Must contain a digit"]

schema.isRequired("email")        // true
schema.requiredFields()           // {"email", "password", "confirm"}
schema.fieldInfo("password")      // FormFieldInfo(path, rules, isRequired)

form.setFieldValue("user.address.city", "Lagos")
form.setFieldValue("tags[1]", "gamma")
form.setFieldError("friends[0].name", "Required")

val friends = form.array("friends")
friends.push("aisha")             // append, doesn't touch
friends.insert(1, "between")
friends.swap(0, 2)
friends.move(2, 0)
friends.remove(0)
friends.pop()
friends.replace(0, "REPLACED")    // doesn't touch

@FormValues
data class LoginValues(val email: String, val password: String)

object LoginValuesPaths {
    const val email    = "email"
    const val password = "password"
}

object LoginValuesUpdater : ValuesUpdater<LoginValues> { /* generated get/set/leafPaths */ }

val form = FormikController(FormikConfig(
    initialValues = LoginValues("", ""),
    valuesUpdater = LoginValuesUpdater,
    onSubmit = { v, _ -> api.login(v.email, v.password) },
))

form.setFieldValue(LoginValuesPaths.email, "user@example.com")
form.setFieldError(LoginValuesPaths.password, "Too short")

tasks.register("generateKFormikTypedPaths") {
    group = "kformik"
    description = "Run KSP to generate @FormValues typed paths and ValuesUpdater objects (no full build)."

    // tasks.matching is lazy and project-shape-agnostic — picks up whatever KSP tasks the active
    // Kotlin / Android / KMP configuration registered: kspKotlin (JVM), kspDebugKotlin (Android),
    // kspCommonMainKotlinMetadata + kspKotlinJvm/IosX64/… (KMP).
    dependsOn(tasks.matching { it.name.startsWith("ksp") && it.name.contains("Kotlin") })
}

// shared commonMain code:
@Composable
fun LoginScreen() {
    val form = rememberFormik(
        initialValues = mapOf<String, Any?>("email" to "", "password" to ""),
        validate = { v -> buildErrors { /* … */ } },
        onSubmit = { v, _ -> /* … */ },
    )
    val state by form.state

    OutlinedTextField(
        value = state.values["email"] as String,
        onValueChange = { form.setFieldValue("email", it) },
        isError = form.displayError("email") != null,
        supportingText = { form.displayError("email")?.let { Text(it) } },
    )
    Button(onClick = { form.submit() }, enabled = !state.isSubmitting) {
        Text("Sign in")
    }
}