Kotlin 2.3 สำหรับ Android: Name-Based Destructuring, KMP และคำถามสัมภาษณ์ 2026

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

fun main() {
    val user = User("alice", "alice@example.com")
    // Position-based: ลำดับสำคัญ ไม่ใช่ชื่อ
    val (email, username) = user
    println(email)    // พิมพ์ "alice" -- ผิด!
    println(username) // พิมพ์ "alice@example.com" -- ผิด!
}

kotlin {
    compilerOptions {
        // โหมด 1: เฉพาะ syntax ที่ระบุชัดเจน
        freeCompilerArgs.add("-Xname-based-destructuring=only-syntax")
        // โหมด 2: แจ้งเตือนเมื่อชื่อไม่ตรงกัน
        // freeCompilerArgs.add("-Xname-based-destructuring=name-mismatch")
        // โหมด 3: Name-based เต็มรูปแบบเป็นค่าเริ่มต้น
        // 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: จับคู่ตามชื่อ property
    val (email, username) = user
    println(email)    // "alice@example.com" -- ถูกต้อง
    println(username) // "alice" -- ถูกต้อง

    // Position-based: วงเล็บเหลี่ยมคงพฤติกรรมเดิม
    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 สำหรับ HTTP engine เฉพาะแพลตฟอร์ม
expect fun createHttpClient(): HttpClient

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

    // Suspend function ที่ใช้ร่วมกันระหว่าง Android และ 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 ใช้ 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 (เสถียร)
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")
}

// ไม่มี context parameter
fun saveUser(id: Int) {
    println("Saving user $id (no logger)")
}

// มี 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()
    // ตอนนี้จะเกิด error ความกำกวมใน Kotlin 2.3.20
    // context(logger) { saveUser(1) }

    // แก้ไข: เปลี่ยนชื่อหรือระบุ variant ที่มี context อย่างชัดเจน
}

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

// Cold Flow: emit เฉพาะเมื่อมีการ collect
fun userUpdates(): Flow<String> = flow {
    println("Flow started") // ทำงานต่อ collector
    emit("User logged in")
    delay(1000)
    emit("User updated profile")
}

// Hot Flow: emit โดยไม่ขึ้นกับ collector
class UserRepository {
    // StateFlow เก็บค่าล่าสุด
    private val _state = MutableStateFlow("idle")
    val state: StateFlow<String> = _state.asStateFlow()

    // SharedFlow กระจายไปยังหลาย 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() {

    // เปิดเผย state ให้ Compose UI
    val uiState: StateFlow<String> = repo.state
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = "idle"
        )

    init {
        // Collect events อย่างปลอดภัยภายใน scope ของ ViewModel
        viewModelScope.launch {
            repo.events.collect { event ->
                // จัดการ event ครั้งเดียว
                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>
}

// การใช้งานใน 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: กำหนดค่าอ็อบเจกต์ คืนค่าอ็อบเจกต์
    return Request().apply {
        url = "https://api.example.com/users"
        method = "POST"
        headers["Content-Type"] = "application/json"
        body = "{\"name\": \"Alice\"}"
    }
}

fun processNullable(input: String?) {
    // let: แปลง nullable คืนค่าผลลัพธ์ lambda
    val length = input?.let { value ->
        println("Processing: $value")
        value.trim().length
    } ?: 0

    // also: ผลข้างเคียง คืนค่าอ็อบเจกต์เดิม
    input?.also { println("Logging input: $it") }

    // run: รันบล็อกกับ receiver คืนค่าผลลัพธ์ lambda
    val result = input?.run {
        // 'this' คือ string
        uppercase().take(10)
    }
}

fun findUser(id: String): User? {
    // คืนค่า null ถ้าไม่พบ user
    return database.queryUser(id)
}

// ไม่ดี: !! ทำลายจุดประสงค์ของ null safety
fun riskyApproach(id: String) {
    val user = findUser(id)!! // NullPointerException ถ้าเป็น null
    println(user.username)
}

// ดี: จัดการ null อย่างชัดเจน
fun safeApproach(id: String) {
    val user = findUser(id) ?: run {
        println("User not found")
        return
    }
    println(user.username)
}

// ดี: ให้ค่าเริ่มต้นด้วย Elvis operator
fun displayName(id: String): String {
    return findUser(id)?.username ?: "Anonymous"
}