Kotlin 2.3 cho Android: Name-Based Destructuring, KMP và Câu Hỏi Phỏng Vấn 2026

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")
    // Position-based: thứ tự quan trọng, không phải tên
    val (email, username) = user
    println(email)    // In ra "alice" -- sai!
    println(username) // In ra "alice@example.com" -- sai!
}

kotlin {
    compilerOptions {
        // Chế độ 1: Chỉ cú pháp tường minh
        freeCompilerArgs.add("-Xname-based-destructuring=only-syntax")
        // Chế độ 2: Cảnh báo khi tên không khớp
        // freeCompilerArgs.add("-Xname-based-destructuring=name-mismatch")
        // Chế độ 3: Name-based đầy đủ làm mặc định
        // freeCompilerArgs.add("-Xname-based-destructuring=complete")
    }
}

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")

    // Name-based: khớp theo tên thuộc tính
    val (email, username) = user
    println(email)    // "alice@example.com" -- đúng
    println(username) // "alice" -- đúng

    // Position-based: ngoặc vuông giữ hành vi cũ
    val [first, second] = user
    println(first)  // "alice" (component1)
    println(second) // "alice@example.com" (component2)
}

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

@Serializable
data class UserProfile(
    val id: String,
    val displayName: String,
    val avatarUrl: String?
)

// Pattern expect/actual cho HTTP engine theo nền tảng
expect fun createHttpClient(): HttpClient

class ApiClient {
    private val client = createHttpClient()
    private val json = Json { ignoreUnknownKeys = true }

    // Hàm suspend chia sẻ giữa Android và iOS
    suspend fun fetchProfile(userId: String): UserProfile {
        val response = client.get("https://api.example.com/users/$userId")
        return json.decodeFromString(response.bodyAsText())
    }
}

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*

// Android sử dụng engine OkHttp
actual fun createHttpClient(): HttpClient = HttpClient(OkHttp) {
    engine {
        config {
            retryOnConnectionFailure(true)
        }
    }
}

class Logger {
    fun log(message: String) = println("[LOG] $message")
}

class Transaction {
    fun execute(query: String) = println("Executing: $query")
}

// Kotlin 2.3: context parameters (ổn định)
context(logger: Logger, tx: Transaction)
fun saveUser(id: Int) {
    logger.log("Saving user $id")
    tx.execute("INSERT INTO users (id) VALUES ($id)")
}

fun main() {
    val logger = Logger()
    val tx = Transaction()
    context(logger, tx) {
        saveUser(42)
    }
}

class Logger {
    fun log(message: String) = println("[LOG] $message")
}

// Không có context parameter
fun saveUser(id: Int) {
    println("Saving user $id (no logger)")
}

// Có context parameter
context(logger: Logger)
fun saveUser(id: Int) {
    logger.log("Saving user $id")
    println("Saving user $id (no logger)")
}

fun main() {
    val logger = Logger()
    // Điều này giờ tạo ra lỗi nhập nhằng trong Kotlin 2.3.20
    // context(logger) { saveUser(1) }

    // Sửa: đổi tên hoặc chỉ định rõ biến thể context-aware
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Cold Flow: chỉ emit khi được collect
fun userUpdates(): Flow<String> = flow {
    println("Flow started") // Chạy cho mỗi collector
    emit("User logged in")
    delay(1000)
    emit("User updated profile")
}

// Hot Flow: emit độc lập với collector
class UserRepository {
    // StateFlow giữ giá trị mới nhất
    private val _state = MutableStateFlow("idle")
    val state: StateFlow<String> = _state.asStateFlow()

    // SharedFlow phát đến nhiều collector
    private val _events = MutableSharedFlow<String>()
    val events: SharedFlow<String> = _events.asSharedFlow()

    suspend fun login() {
        _state.value = "loading"
        delay(500)
        _state.value = "authenticated"
        _events.emit("login_success")
    }
}

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

class UserViewModel(private val repo: UserRepository) : ViewModel() {

    // Cung cấp state cho Compose UI
    val uiState: StateFlow<String> = repo.state
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = "idle"
        )

    init {
        // Collect events an toàn trong phạm vi ViewModel
        viewModelScope.launch {
            repo.events.collect { event ->
                // Xử lý sự kiện một lần
                println("Event received: $event")
            }
        }
    }
}

sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val message: String, val retry: (() -> Unit)? = null) : UiState<Nothing>
}

// Sử dụng trong ViewModel
fun loadUsers(): Flow<UiState<List<UserProfile>>> = flow {
    emit(UiState.Loading)
    try {
        val users = apiClient.fetchUsers()
        emit(UiState.Success(users))
    } catch (e: Exception) {
        emit(UiState.Error(
            message = e.localizedMessage ?: "Unknown error",
            retry = { /* trigger reload */ }
        ))
    }
}

data class Request(
    var url: String = "",
    var method: String = "GET",
    var headers: MutableMap<String, String> = mutableMapOf(),
    var body: String? = null
)

fun buildRequest(): Request {
    // apply: cấu hình đối tượng, trả về đối tượng
    return Request().apply {
        url = "https://api.example.com/users"
        method = "POST"
        headers["Content-Type"] = "application/json"
        body = "{\"name\": \"Alice\"}"
    }
}

fun processNullable(input: String?) {
    // let: biến đổi nullable, trả về kết quả lambda
    val length = input?.let { value ->
        println("Processing: $value")
        value.trim().length
    } ?: 0

    // also: hiệu ứng phụ, trả về đối tượng gốc
    input?.also { println("Logging input: $it") }

    // run: thực thi khối với receiver, trả về kết quả lambda
    val result = input?.run {
        // 'this' là string
        uppercase().take(10)
    }
}

fun findUser(id: String): User? {
    // Trả về null nếu không tìm thấy user
    return database.queryUser(id)
}

// Xấu: !! đánh bại mục đích của null safety
fun riskyApproach(id: String) {
    val user = findUser(id)!! // NullPointerException nếu null
    println(user.username)
}

// Tốt: xử lý null rõ ràng
fun safeApproach(id: String) {
    val user = findUser(id) ?: run {
        println("User not found")
        return
    }
    println(user.username)
}

// Tốt: cung cấp giá trị mặc định với Elvis operator
fun displayName(id: String): String {
    return findUser(id)?.username ?: "Anonymous"
}