// Traditional approach - lots of boilerplate
val scope = rememberCoroutineScope()
var isLoading by remember { mutableStateOf(false) }

Button(
    onClick = {
        if (!isLoading) {
            scope.launch {
                isLoading = true
                try {
                    submitForm()
                } finally {
                    isLoading = false
                }
            }
        }
    },
    enabled = !isLoading
) {
    if (isLoading) CircularProgressIndicator() else Text("Submit")
}

// With modifier - 1 line
Button(
    onClick = {},
    modifier = Modifier.asyncThrottleClick { submitForm() }
) {
    Text("Submit")
}

// With AsyncButton - automatic loading state
AsyncButton(
    onClick = { submitForm() }
) { isLoading ->
    if (isLoading) CircularProgressIndicator() else Text("Submit")
}

commonMain.dependencies {
    implementation("io.github.vietnguyentuan2019:kmp-event-limiter:1.0.0")
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation(libs.kmp.event.limiter)
        }
    }
}

Button(
    onClick = {},
    modifier = Modifier.throttleClick(duration = 500.milliseconds) {
        submitOrder()
    }
) {
    Text("Submit Order")
}

val scope = rememberCoroutineScope()
val throttler = remember { Throttler(scope) }

Button(onClick = throttler.wrap { submitOrder() }) {
    Text("Submit Order")
}

var searchQuery by remember { mutableStateOf("") }
var searchResults by remember { mutableStateOf<List<Product>>(emptyList()) }
var isSearching by remember { mutableStateOf(false) }

AsyncDebouncedTextField(
    value = searchQuery,
    onValueChange = { searchQuery = it },
    onDebouncedChange = { query ->
        // This is a suspend function called after 500ms pause
        searchApi(query)
    },
    onSuccess = { results ->
        searchResults = results
    },
    onLoadingChanged = { loading ->
        isSearching = loading
    },
    debounceTime = 500.milliseconds,
    trailingIcon = {
        if (isSearching) CircularProgressIndicator(modifier = Modifier.size(24.dp))
        else Icon(Icons.Default.Search, "Search")
    }
)

AsyncButton(
    onClick = {
        // Suspend function automatically manages loading state
        uploadFile()
    },
    onError = { error ->
        showSnackbar("Upload failed: ${error.message}")
    }
) { isLoading ->
    if (isLoading) {
        Row {
            CircularProgressIndicator(modifier = Modifier.size(20.dp))
            Spacer(Modifier.width(8.dp))
            Text("Uploading...")
        }
    } else {
        Text("Upload File")
    }
}

val scope = rememberCoroutineScope()
val messageSender = remember {
    ConcurrentAsyncThrottler(
        scope = scope,
        mode = ConcurrencyMode.ENQUEUE
    )
}

ConcurrentAsyncButton(
    onClick = {
        messageSender.call {
            sendMessage(messageText)
        }
    },
    mode = ConcurrencyMode.ENQUEUE
) { isLoading, pendingCount ->
    Text(
        if (pendingCount > 0) "Sending ($pendingCount)..." else "Send"
    )
}

val scope = rememberCoroutineScope()
val searchController = remember {
    ConcurrentAsyncThrottler(
        scope = scope,
        mode = ConcurrencyMode.REPLACE
    )
}

TextField(
    value = searchQuery,
    onValueChange = { query ->
        searchQuery = query
        scope.launch {
            searchController.call {
                // Old search calls are cancelled
                val results = searchApi(query)
                searchResults = results
            }
        }
    }
)

val scope = rememberCoroutineScope()
val autoSaver = remember {
    ConcurrentAsyncThrottler(
        scope = scope,
        mode = ConcurrencyMode.KEEP_LATEST
    )
}

TextField(
    value = documentText,
    onValueChange = { text ->
        documentText = text
        scope.launch {
            autoSaver.call {
                saveDraft(text) // Only saves current + final version
            }
        }
    }
)

class Throttler(
    scope: CoroutineScope,
    duration: Duration = 500.milliseconds,
    debugMode: Boolean = false,
    name: String? = null,
    enabled: Boolean = true,
    resetOnError: Boolean = false,
    onMetrics: ((Duration, Boolean) -> Unit)? = null
)

class AsyncThrottler(
    scope: CoroutineScope,
    maxDuration: Duration? = 15.seconds,
    // ... same params as Throttler
)

class ConcurrentAsyncThrottler(
    scope: CoroutineScope,
    mode: ConcurrencyMode = ConcurrencyMode.DROP,
    maxDuration: Duration? = null,
    // ...
)

fun Modifier.throttleClick(
    duration: Duration = 500.milliseconds,
    enabled: Boolean = true,
    onClick: () -> Unit
): Modifier

fun Modifier.throttleClickable(
    duration: Duration = 500.milliseconds,
    enabled: Boolean = true,
    onClick: () -> Unit
): Modifier // With ripple effect

fun Modifier.asyncThrottleClick(
    maxDuration: Duration? = null,
    mode: ConcurrencyMode = ConcurrencyMode.DROP,
    enabled: Boolean = true,
    onClick: suspend () -> Unit
): Modifier

@Composable
fun AsyncButton(
    onClick: suspend () -> Unit,
    modifier: Modifier = Modifier,
    enabled: Boolean = true,
    mode: ConcurrencyMode = ConcurrencyMode.DROP,
    maxDuration: Duration? = null,
    onError: ((Throwable) -> Unit)? = null,
    loadingIndicator: @Composable () -> Unit = { CircularProgressIndicator() },
    content: @Composable (isLoading: Boolean) -> Unit
)

@Composable
fun DebouncedTextField(
    value: String,
    onValueChange: (String) -> Unit,
    onDebouncedChange: suspend (String) -> Unit,
    modifier: Modifier = Modifier,
    debounceTime: Duration = 500.milliseconds,
    // ... standard TextField params
)

@Composable
fun <T> AsyncDebouncedTextField(
    value: String,
    onValueChange: (String) -> Unit,
    onDebouncedChange: suspend (String) -> T?,
    modifier: Modifier = Modifier,
    onSuccess: ((T) -> Unit)? = null,
    onError: ((Throwable) -> Unit)? = null,
    onLoadingChanged: ((Boolean) -> Unit)? = null,
    // ...
)