interface Element {
  val active: Boolean
}
class ActualElement : Element {
  override var active: Boolean = false // 오버라이드
}

val str: String? = "Hello"

if (str != null) {
    println(str.length) // ✅ 가능
}

val name: String? = "Marton"
val surname: String = "Braun"

val fullName: String? 
    get() = name?.let { "$it $surname" }
val fullName2: String? = name?.let { "$it $surname" }

fun main() {
    if (fullName != null) {
        println(fullName.length) // 오류
    }
    
    if (fullName2 != null) {
        println(fullName2.length)
    }
}

val mutable = mutableListOf(1, 2, 3)
val readOnly: List<Int> = mutable

mutable.add(4)

println(readOnly) // 👉 [1, 2, 3, 4] 읽기 전용 컬렉션 List도 인터페이스에서 변경 메서드가 없을뿐 실제로 변경될 수 있음!

inline fun<T, R> Iterable<T>.map(
    transformation: (T) -> R
): List<R> {
    val list = ArrayList<R>()
    for (elem in this){
        list.add(transformation(elem))
    }
    return list
}

data class(
    val name: String,
    val surname: String,
)

var user = User("Maja", "Markiewicz")
user = user.copy(usrname = "Moska") // 새로운 프로퍼티 지정 가능
print(user) // User(name=Maja, surname=Moska)

val list1: MutableList<Int> = mutableListOf()
var list2: List<Int> = listOf()

list1.add(1)
list2 = list2 + 1

list1 += 1 // list1.plusAssign(1)
list2 += 1 // list2 = list2.plus(1)

var num = 0
for (i in 1..1000) {
  thread {
    Thread.sleep(10)
    num += 1
  }
}

Thread.sleep(5000)
print(num) // 1000이 출력될 가능성이 거의 없다. 매번 다른 숫자가 출력된다. 동시성 문제..

val lock = Any()
for (i in 1..1000) {
  thread {
    Thread.sleep(10)
    synchronized(lock) {
      num += 1
    }
  }
}
Thread.sleep(1000)
print(num) // 1000

data class User(val name: String)

class UseRepository {
  private val users: MutableList<User> = mutableLlistOf()
  
  fun loadAll(): MutableList<User> = users
  //...
}

val users = userRepo.loadAll()
users.add(User("Jeon"))
// ...
println(userRepo.loadAll()) // User(name=Jeon)

== Java ==
public class UserRepo {
  public User getUser() {
    // ...
  }
}

== Kotlin ==
val repo = UserRepo()
val user1 = repo.user // 플랫폼 타입, nonnull 선언 가능
val user2: User = repo.user // 플랫폼 타입, nonnull 선언 가능
val user3: User? = repo.user // 플랫폼 타입, nullable 선언 가능

== Java ==
public class JavaClass {
  public String getValue() {
    return null;
  }
}

== Kotlin ==
fun statedType() {
  val value: String = JavaClass().value // 자바에서 값을 가져오는 라인에서 NPE 발생
  println(value.length)
}

fun platformType() {
  val value = JavaClass().value // nonnull로 선언되었지만 null이 반환되었으므로 여기서 NPE 발생
  println(value)
}

public clas UserRepo {
  public @NotNull User getUser() {
    // ...
  }
}

inline fun <reified T> String.readObjectOrNull(): T? {
    // ...
    if (incorrectSign) {
        return null
    }
    // ...
    return result
}

inline fun <reified T> String.readObject(): Result<T> {
    // ...
    if (incorrectSign) {
        return Failure(JsonParsingException())
    }
    // ...
    return Success(result)
}

class JsonParsingException: Exception()

userText.readObject<Person>(
  .onSuccess { showPersonAge(it) }
  .onFailure { showError(it) }
)

fun getA(): Result<T> = runCatching { getAThrowing() }

// ✅ 1. 기본 사용 예제 (성공 / 실패 반환)
fun parseInt(input: String): Result<Int> {
    return runCatching {
        input.toInt()  // 여기서 NumberFormatException 발생 가능
    }
}

fun main() {
    val success = parseInt("123")
    val failure = parseInt("abc")

    println(success.getOrNull())   // 123
    println(failure.getOrNull())   // null

    println(failure.exceptionOrNull()) // NumberFormatException
}

// ✅ 2. 결과 처리 (onSuccess / onFailure)
fun main() {
    parseInt("100")
        .onSuccess { value ->
            println("성공: $value")
        }
        .onFailure { exception ->
            println("실패: ${exception.message}")
        }

    parseInt("abc")
        .onSuccess { value ->
            println("성공: $value")
        }
        .onFailure { exception ->
            println("실패: ${exception.message}")
        }
}

// ✅ 3. map / recover 활용 (변환 + 에러 복구)
fun main() {
    val result = parseInt("123")
        .map { it * 2 }  // 성공 값 변환
        .recover { -1 }  // 실패 시 기본값

    println(result.getOrNull()) // 246

    val failed = parseInt("abc")
        .map { it * 2 }
        .recover { -1 }

    println(failed.getOrNull()) // -1
}

// ✅ 4. 실무 스타일 (서비스 로직)
data class User(val id: Int, val name: String)

fun findUser(id: String): Result<User> {
    return runCatching {
        val parsedId = id.toInt()
        // DB 조회라고 가정
        if (parsedId == 1) {
            User(1, "Alice")
        } else {
            throw IllegalArgumentException("User not found")
        }
    }
}

fun main() {
    val userName = findUser("1")
        .map { it.name }
        .getOrElse { "Unknown User" }

    println(userName) // Alice

    val unknown = findUser("abc")
        .map { it.name }
        .getOrElse { "Unknown User" }

    println(unknown) // Unknown User
}

// 코틀린 - 타입으로 null 가능 여부가 명확함 ✅
val name: String = getName()   // null 절대 불가
val name: String? = getName()  // null 가능

// 안전하게 다루는 문법도 내장
val length = name?.length          // Safe call
val length = name?.length ?: 0    // Elvis 연산자
val length = name!!.length         // Non-null 단언 (위험)

// 피보나치 수를 계산하는 fib 함수에 대한 단위테스트
@Test
fun `fib works correctly for the first 5 positions()` {
  assertEqulas(1, fib(0))
  assertEqulas(1, fib(1))
  assertEqulas(2, fib(2))
  assertEqulas(3, fib(3))
  assertEqulas(5, fib(4))
}

// 구현 A
if (person != null && perso.isAdult) {
    view.showPerson(person)
} else {
    view.showError()
}

// 구현 B
person?.takeIf { it.isAdult }
    ?.let(view::showPerson)
    ?: view.showError()

fun main() {
  students
    .filter { it.result >= 50 }
    .joinToString(separator = "\n") {
        "${it.name} ${it.surname}, ${it.result}"
    }
    .let(::print)
  
  var obj = FileInputStream("/file.gz")
    .let(::BufferedInputStream)
    .let(::ZipInputStream)
    .let(::ObjectInputStream)
    .readObject() as SomeObject
}

// ex1 - 큰 숫자
val netPrice = BigDecimal("10")
val tax = BigDecimal("0.23")
val currentBalance = BigDecimal("20")
val newBalance = currentBalance.minus(netPrice.times(tax)) // 함수 사용
val newBalance2 = currentBalance - netPrice * tax // 연산자 사용 - 가독성 좋음
println(newBalance) // 17.70

// ex2 - 시간 및 기간
val now = ZonedDateTime.now()
val duration = Duration.ofDays(1)
val sameTimeTomorrow = now.plus(duration) // 함수 사용
val sameTimeTomorrow2 = now + duration // 연산자 사용 - 가독성 좋음

// ex3 - 컬렉션에 요소가 포함되어있는지 확인
val SUPPORTED_TAGS = setof("ADMIN", "TRAINER", "ATTENDEE")
val tag = "ATANDEE"

println(SUPPORTED_TAGS.contains(tag)) // 함수 사용
println(tag in SUPPORTED_TAGS) // 연산자 사용

val num = 10
val name = "Marcin"
val ids = listOf(12, 112, 554, 997)

val data = getSomeData()

// build.gradle(.kts)

koltin {
  // 엄격 모드용
  explicitApi()

  // 경고 모드용
  explicitApiWarning()
}

class User: Person() {
  private var beersDrunk: Int = 0
    fun drinkBeers(num: Int) {
      // ...
      this.beersDrunk += num
      // ...
  }
}

fun <T : Comparable<T>> List<T>.quickSort(): List<T> {
  if (this.size < 2) return this
  val pivot = this.first()
  val (smaller, bigger) = this.drop(1).partition { it < pivot }
  return smaller.quickSort() + pivot + bigger.quickSort()
}

class Node(val name: String) {
  fun makeChild(childName: String) = create("$name.$childName")
                                      .apply{ print("Created ${this.name}") } // 컴파일 오류
  fun create(name: String): Node? = Node(name)
}

fun main() {
  val node = Node("parent")
  node.makeChild("child")
}

class Node(val name: String) {
  fun makeChild(childName: String) = create("$name.$childName")
                                      .apply{ print("Created ${this?.name}") }

  fun create(name: String): Node? = Node(name)
}

fun main() {
  val node = Node("parent")
  node.makeChild("child")
}

class Node(val name: String) {
  fun makeChild(childName: String) = create("$name.$childName").apply{
    print("Created ${this?.name} in " + "${this@Node.name}")
  }

  fun create(name: String): Node? = Node(name)
}

fun main() {
  val node = Node("parent")
  node.makeChild("child")
}

var name: String? = null
String name = null

var name: String? = null
  get() = field?.toUpperCase()
  set(value) {
    if (!value.isNullOrBlack()) {
      field = value
    }
  }

// 아래 인터페이스에는 게터가 있다는 것을 의미한다.
interface Person {
  val name: String
}

// 프로퍼티로 정의
val Tree<Int>.sum: Int
  get() = when (this) {
    is Leaf -> value
    is Node -> left.sum + right.sum
  }

// 함수로 정의
fun Tree<Int>.sum(): Int = when (this) {
    is Leaf -> value
    is Node -> left.sum() + right.sum()
}

// 아래처럼 간단한 상태를 가져오고 설정할때 함수를 사용해선 안됨
class UserIncorrect {
    private var name: String = ""

    fun getName() = name
    fun setName(name: String) {
        this.name = name
    }
}

// 아래와 같이 프로퍼티로 정의
class UserCorrect {
    var name: String = ""
}

// 외부 API 직접 사용
Picasso.get()
  .load(url)
  .into(imageView)

// 래핑한 추상화 계층
fun ImageView.loadImage(url: String) {
  Picasso.get()
    .load(url)
    .into(this)
}

// ===== 1. 추상화 인터페이스 =====
interface FileStorageClient {
  fun upload(key: String, data: ByteArray, contentType: String = "application/octet-stream"): String
  fun download(key: String): ByteArray
  fun delete(key: String)
  fun exists(key: String): Boolean
  fun getPublicUrl(key: String): String
}

// ===== 2. AWS S3 래퍼 구현체 =====
// ✨ 다른 오브젝트 스토리지로 변경이 필요할 경우 새로운 구현체만 구현해주면됨
class S3FileStorageClient(
  private val bucketName: String,
  region: String = "ap-northeast-2"
) : FileStorageClient {

  // AWS S3Client (외부 라이브러리)
  private val s3Client: S3Client = S3Client.builder()
      .region(Region.of(region))
      .build()

  override fun upload(key: String, data: ByteArray, contentType: String): String {
      val request = PutObjectRequest.builder()
          .bucket(bucketName)
          .key(key)
          .contentType(contentType)
          .build()

      s3Client.putObject(request, RequestBody.fromBytes(data))

      return key
  }

  override fun download(key: String): ByteArray {
      val request = GetObjectRequest.builder()
          .bucket(bucketName)
          .key(key)
          .build()

      return s3Client.getObject(request).readAllBytes()
  }
  
  // ...
}

// ===== 3. 비즈니스 로직 - FileStorageClient에만 의존 =====
class UserProfileService(
  private val storage: FileStorageClient   // AWS든 InMemory든 상관없음
) {
  fun uploadProfileImage(userId: Long, imageBytes: ByteArray): String {
      val key = "profiles/$userId/avatar.jpg"
      storage.upload(key, imageBytes, contentType = "image/jpeg")
      return storage.getPublicUrl(key)
  }

  fun getProfileImageUrl(userId: Long): String {
      val key = "profiles/$userId/avatar.jpg"
      check(storage.exists(key)) { "Profile image not found for user $userId" }
      return storage.getPublicUrl(key)
  }
}

interface Tool {
  copanion object { ... }
}

fun Tool.Companion.createBigTool(...): Tool {
  // ...
}

val tool = Tool.createBigTool()

// 아래와 같은 추상 동반 객체 팩토리는 값을 가질 수 있으므로, 캐싱을 구현할 수도 있고 테스트 용도로 가짜 객체를 만들 수도 있음
abstract class ActivityFactor{
	abstract fun getIntent(context: Cotnext) : Intent
	
  fun start(context : Context)[
    val intent = getIntent(context)
      context.startActivity(intent)
  }
}

class MainActivity : AppCompatActivity{

  companion object : ActivityFactory() {
    overide fun getIntext(cotnext: Context) Intent =
      Intent(context ,MainActivity::class.java
    }
}

// 사용법
val intent = MainActivity.getIntent(context)
MainActivity.start(context)

val list = buildList {
  add(1)
  add(2)
  add(3)
}
println(list) // [1, 2, 3]

val s = sequence {
  yield("A")
  yield("B")
  yield("C")
}
println(s.toList()) // [A, B, C]

val sequence: Sequence = list.asSequence()
val double: Double = i.toDouble()

class User(
  val id: UserId,
  val name: String,
  val surname: String,
  val age: Int,
  val tokens: List<Token>
)

class UserJson(
  val id: UserId,
  val name: String,
  val surname: String,
  val age: Int,
  val tokens: List<Token>
)

fun User.toUserJson() = UserJson(
  id = this.id,
  name = this.name,
  surname = this.surname,
  age = this.age,
  tokens = this.token,
)

fun UserJson.toUser() = User(
  id = this.id,
  name = this.name,
  surname = this.surname,
  age = this.age,
  tokens = this.token,
)

val user2 = user.copy()
val user3 = user.withSurname(newSurname)

class A
val a = A()

data class Student(
    val id: Int,
    val name: String,
    val surname: String
)
​
class StudentsFactory {
    var nextId = 0
    fun next(name: String, surname: String) = Student(nextId++. name, surname)
}

class UserFactory(
  private val uuidProvider: UuidProvider,
  private val timeProvider: TimeProvider,
  private val tokenProvider: TokenProvider,
) {
  fun create(newUserData: NewUserData): User {
    val id = uuidProvider.next()
    return User(
      id = id,
      creationTime = timeProvider.now(),
      token = tokenServicwe.generateToken(id),
      name = newUserData.name,
      surname = newUserData.surname,
      // ...
    )
  }
}

// 1. object 키워드로 싱글톤 유틸리티 클래스
object StringUtils {

  fun capitalize(str: String): String =
      str.replaceFirstChar { it.uppercaseChar() }

  fun reverse(str: String): String =
      str.reversed()

  fun isPalindrome(str: String): Boolean {
      val cleaned = str.lowercase().replace("\\s".toRegex(), "")
      return cleaned == cleaned.reversed()
  }

  fun countWords(str: String): Int =
      if (str.isBlank()) 0 else str.trim().split("\\s+".toRegex()).size

  fun truncate(str: String, maxLength: Int): String =
      if (str.length <= maxLength) str else "${str.take(maxLength)}..."

  fun camelToSnake(str: String): String =
      str.replace("([a-z])([A-Z])".toRegex(), "$1_$2").lowercase()
}

// 사용 예시
fun main() {
    println(StringUtils.capitalize("hello world"))        // Hello world
    println(StringUtils.reverse("Kotlin"))                // niltoK
    println(StringUtils.isPalindrome("racecar"))          // true
    println(StringUtils.countWords("Hello Kotlin World")) // 3
    println(StringUtils.truncate("Hello, Kotlin!", 5))    // Hello...
    println(StringUtils.camelToSnake("camelCaseString"))  // camel_case_string
}

// 2. 코틀린스러운 확장 함수 방식으로도 가능
fun String.capitalize2(): String =
    replaceFirstChar { it.uppercaseChar() }

fun String.isPalindrome(): Boolean {
    val cleaned = lowercase().replace("\\s".toRegex(), "")
    return cleaned == cleaned.reversed()
}

fun String.countWords(): Int =
    if (isBlank()) 0 else trim().split("\\s+".toRegex()).size

fun String.truncate(maxLength: Int): String =
    if (length <= maxLength) this else "${take(maxLength)}..."

// 사용 예시
fun main() {
    println("hello world".capitalize2())   // Hello world
    println("racecar".isPalindrome())      // true
    println("Hello Kotlin World".countWords()) // 3
    println("Hello, Kotlin!".truncate(5)) // Hello...
}

class Pizza {
  val size: String
  val cheese: Int
  val olives: Int
  val bacon: Int

  constructor(
    size: String,
    cheese: Int,
    olives: Int,
    bacon: Int
  ) {
    // ...
  }

  constructor(
    size: String,
    cheese: Int,
    olives: Int
  ) {
    // ...
  }
}

== 디폴트 인수 사용 ==
class Pizza (
  val size: String,
  val cheese: Int = 0,
  val olives: Int = 0,
  val bacon: Int = 0
)

val myFavorite = Pizze("L", olives = 3)
val myFavorite = Pizze("L", olives = 3, cheese = 1)

val vaillagePizze = Pizza(
  size = "L",
  cheese = 1,
  olives = 2,
  bacon = 3,
)

== DSL 빌더 ==
val dialog = context.alert(R.string.fire_missiles) {
  positiveButton(R.string.fire) {
    // 미사일 발사!
  }
  negativeButton {
    // 사용자가 대화사장에서 취소를 누른 경우
  }
}

val route = router {
  "/home" directsTo ::showHome
  "/users" directsTo ::showUsers
}

== 일부 프로퍼티만 설정한 상태에서 다른 객체에 전달하는 팩토리 방식 ==
fun Context.makeDefaultDialogBuilder() =
  AlertDialog.Builder(this)
             .setIcon(R.drawable.ic_dialog)
             .setTitle(R.string.dialog_title)
             .setOnCancleListener { it.cancel() }

== 코틀린의 선택적 매개변수가 있는 함수를 사용하는 대안 ==
data class DialogConfig(
  val icon: Int,
  val title: Int,
  val onCancelListener: (() -> Unit)?,
  // ...
)

val defaultDialogConfig = DialogConfig(
  icon = R.drawable.ic_dialog,
  title = R.string.dialog_title,
  onCancelListener = { it.cancel() },
  // ...
)

// 또는
fun defaultDialogConfig(
  val icon: Int = R.drawable.ic_dialog,
  val title: Int = R.string.dialog_title,
  val onCancelListener: (() -> Unit)? = { it.cancel() }
) = DialogConfig(icon, title, onCancelListener, /*..*/)

// 1. 단일 스코프 DSL — @DslMarker 불필요
data class Product(
    val name: String,
    val price: Int,
    val category: String,
    val tags: List<String>
)

class ProductBuilder {
    var name: String = ""
    var price: Int = 0
    var category: String = ""
    val tags = mutableListOf<String>()

    fun tag(vararg values: String) { tags.addAll(values) }
    fun build() = Product(name, price, category, tags)
}

fun product(block: ProductBuilder.() -> Unit): Product =
    ProductBuilder().apply(block).build()

val product = product {
    name = "코틀린 완벽 가이드"
    price = 35000
    category = "도서"
    tag("개발", "코틀린", "베스트셀러")
}

// 2. 중첩 스코프 DSL — @DslMarker 필요
@DslMarker
annotation class ProductDsl

// 데이터 클래스
data class Discount(val rate: Int, val condition: String)
data class Shipping(val fee: Int, val estimatedDays: Int)
data class Product(
    val name: String,
    val price: Int,
    val discount: Discount,
    val shipping: Shipping
)

// 중첩 빌더
@ProductDsl
class DiscountBuilder {
    var rate: Int = 0
    var condition: String = "상시"
    fun build() = Discount(rate, condition)
}

@ProductDsl
class ShippingBuilder {
    var fee: Int = 3000
    var estimatedDays: Int = 3
    fun build() = Shipping(fee, estimatedDays)
}

@ProductDsl
class ProductBuilder {
    var name: String = ""
    var price: Int = 0
    private var discount = DiscountBuilder()
    private var shipping = ShippingBuilder()

    fun discount(block: DiscountBuilder.() -> Unit) {
        discount = DiscountBuilder().apply(block)
    }

    fun shipping(block: ShippingBuilder.() -> Unit) {
        shipping = ShippingBuilder().apply(block)
    }

    fun build() = Product(name, price, discount.build(), shipping.build())
}

fun product(block: ProductBuilder.() -> Unit): Product =
    ProductBuilder().apply(block).build()

// 클라이언트 코드
Product(name="무선 키보드", 
        price=89000,
        discount=Discount(rate=10, condition="회원 전용"),
        shipping=Shipping(fee=0, estimatedDays=2))

val product = product {
    name = "무선 키보드"
    price = 89000

    discount {
        rate = 10
        condition = "회원 전용"
        // name = "오타"  ← 컴파일 에러! ProductBuilder.name 접근 차단
    }

    shipping {
        fee = 0
        estimatedDays = 2
    }
}

println(product)

// 핵심 원리 — 람다는 바깥 스코프를 그대로 캡처하여 참조 가능하다.
// discount { } 블록은 DiscountBuilder를 this로 갖지만, 바깥 product { } 블록의 this(= ProductBuilder)도 동시에 접근 가능한 상태이다.
val product = product {           // this = ProductBuilder
    name = "무선 키보드"
    discount {                    // this = DiscountBuilder, 하지만 바깥 ProductBuilder도 스코프에 살아있음
        rate = 10
        name = "???"              // DiscountBuilder.name? → 없음, ProductBuilder.name? → 있음! ← 이걸 건드림
    }
}

@Target(AnnotationTarget.ANNOTATION_CLASS)  // ← 어노테이션 클래스에만 붙일 수 있음
@Retention(AnnotationRetention.BINARY)
@MustBeDocumented
annotation class DslMarker

// HTML DSL
body {
    div {
        a("https://kotlinlang.org") {
            target = ATarget.blank + "Main site"
        }
    }
    +"some content"
}

// Andriod View DSL (Anko 라이브러리)
verticalLayout {
    val name = editText()
    button("Say Hello") {
        onClick { toast("Hello, ${name.text}!")}
    }
}

// Test DSL
class MyTests: StringSpec({
    "반환되는 길이는 String의 크기이어야 합니다." {
        "test string".length shouldBe 5
    }
    "startsWith 함수는 prefix를 반환해야 합니다." {
        "world" should startWith("wor")
    }
})

// Gradle DSL
plugins {
    'java-library'
}

dependencies {
    api("junit:junit:4.12")
    implementation("junit:junit:4.12")
    testImplementation("junit:junit:4.12")
}

configurations {
    implementation {
        resolutionStrategy.failOnVersionConflict()
    }
}

val plus: Int.(Int) -> Int = { other ->
    this + other
}

val result = 10.plus(5)
println(result) // 15

class Dialog {
  var title: String = ""
  var text: String = ""
  fun show() { /*..*/}
}

// 리시버가 있는 람다 함수를 사용하면 this가 dialog를 가리키게 되어, dialog를 반복해서 적을 필요 없이 생략할 수 있음
fun main() {
  val dialog = Dialog()
  val init: Dialog.() -> Unit = {
    title = "my dialog"
    text = "some text"
  }
  init.invoke(dialog)
  dialog.show()
}

// dialog 생성 및 표시의 모든 공통 부분을 취하고 프로퍼티 설정만 사용자에게 맡기는 함수를 정의할 수도 있음 
fun showDialog(init: Dialog.() -> Unit) {
  val dialog = Dialog()
  init.invoke(dialog)
  dialog.show()
}

fun main() {
  showDialog {
    title = "my dialog"
    text = "some text"
  }
}

// 의존성 (build.gradle.kts)
dependencies {
    implementation("org.apache.poi:poi-ooxml:5.2.3")
}


// ────────────────────────────────────────────
// DSL 빌더 클래스들(DSL 정의)
// ────────────────────────────────────────────
import org.apache.poi.xssf.usermodel.XSSFWorkbook
import org.apache.poi.ss.usermodel.Workbook
import org.apache.poi.ss.usermodel.Sheet
import org.apache.poi.ss.usermodel.Row

class ExcelBuilder {
  private val workbook: XSSFWorkbook = XSSFWorkbook()
  private var sheetIndex = 0

  fun sheet(name: String = "Sheet${++sheetIndex}", block: SheetBuilder.() -> Unit) {
      val sheet = workbook.createSheet(name)
      SheetBuilder(sheet).apply(block)
  }

  fun build(): Workbook = workbook
}

class SheetBuilder(private val sheet: Sheet) {
  private var rowIndex = 0

  fun row(block: RowBuilder.() -> Unit) {
      val row = sheet.createRow(rowIndex++)
      RowBuilder(row).apply(block)
  }
}

class RowBuilder(private val row: Row) {
  private var cellIndex = 0

  fun cell(vararg values: Any) { // 가변 인자로 여러 값 입력 가능
      values.forEach { value ->
          val cell = row.createCell(cellIndex++)
          when (value) {
              is String  -> cell.setCellValue(value)
              is Double  -> cell.setCellValue(value)
              is Int     -> cell.setCellValue(value.toDouble())
              is Boolean -> cell.setCellValue(value)
              else       -> cell.setCellValue(value.toString())
          }
      }
  }
}


// ────────────────────────────────────────────
// 진입점 DSL 함수
// ────────────────────────────────────────────
fun excelBuilder(block: ExcelBuilder.() -> Unit): Workbook {
    return ExcelBuilder().apply(block).build()
}


// 사용 예제
import java.io.FileOutputStream

fun main() {
  val workbook = excelBuilder {
    sheet("직원 목록") {
      // 헤더
      row {
        cell("이름", "부서", "연봉")
      }
      // 데이터 반복
      val employees = listOf(
        Triple("김철수", "개발팀", 5000),
        Triple("이영희", "디자인팀", 4500),
        Triple("박민준", "기획팀", 4800),
      )
      for ((name, dept, salary) in employees) {
        row {
            cell(name, dept, salary)
        }
      }
    }

    sheet("숫자 테이블") {
      for (i in 1..5) {
        row {
            cell("행 $i", i * 10, i * 3.14)
        }
      }
    }
  }

  FileOutputStream("output.xlsx").use { workbook.write(it) }
  workbook.close()
  println("output.xlsx 생성 완료!")
}

@DslMarker
annotation class ExcelDsl

@ExcelDsl class ExcelBuilder { ... }
@ExcelDsl class SheetBuilder { ... }
@ExcelDsl class RowBuilder { ... }

data class FullName(
    val firstName: String,
    val secondName: String,
    val lastName: String
)

val elon = FullName("Elon", "Reeve", "Musk")
val (name, surname) = elon // X
val (firstName, secondName) = elon = // O
print("It is $name $surname!") // It is Elon Reeve!

fun String.parseName(): Pair<String, String>? {
    val indexOfLastSpace = this.trim().lastIndexOf(' ')
    if (indexOfLastSpace < 0) return null
    val firstName = this.take(indexOfLastSpace)
    val lastName = this.drop(indexOfLastSpace)
    return Pair(firstName, lastName)
}

val fullName = "Marcin Moskala"
val (lastName, firstName) = fullName.parseName() ?: return
print("His name is $firstName") // His name is Moskala

data class FullName(
    val firstName: String,
    val lastName: String
)

fun String.parseName(): FullName? {
    val indexOfLastSpace = this.trim().lastIndexOf(' ')
    if (indexOfLastSpace < 0) return null
    val firstName = this.take(indexOfLastSpace)
    val lastName = this.drop(indexOfLastSpace)
    return FullName(firstName, lastName)
}

val fullName = "Marcin Moskala"
val (lastName, firstName) = fullName.parseName() ?: return

repeat(10) {
  print(it)
}

// 아래 코드로 대체됨
for (index in 0 until 10) {
  print(index)
} 

inline fun <T> printTypeName() {
  print(T::class.simpleName) // ERROR
}

inline fun <reified T> printTypeName() {
  print(T::class.simpleName) // OK
}

printTypeName<Int>()
printTypeName<Char>()
printTypeName<String>()

// 더 빠름. 호출자 부분에 대체되어 실행시 점프하거나 백스택(back-stack)을 추적할 필요가 없음
inline fun repeat(times: Int, action: (Int) -> Unit) {
  for (index in 0 until times) {
    action(index)
  }
}

// 훨씬 더 느림. 왜? 인수로 들어온 함수 때문에 매번 객체를 가져온 뒤 처리하기 때문(p.348 참고)
fun noinlineRepeat(times: Int, action: (Int) -> Unit) {
  for (index in 0 until times) {
    action(index)
  }
}

for main() {
  noinlineRepeat(10) {
    print(it)
    return // ERROR: 허용되지 않음
  }
}

for main() {
  repeat(10) {
    print(it)
    return // OK: 코드가 어차피 main 함수내에 위치하게 되므로 반환이 가능하게됨, 다른 제어구조와 비슷하게 동작하게됨
  }
}

// 1. 실행 시간 측정
inline fun measureTime(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

// 클라이언트 코드
val elapsed = measureTime {
    heavyDatabaseQuery() // 람다를 넘길 때마다 객체가 생성되는 오버헤드를 없애줌
}


// 2. 로그 + 조건부 실행
inline fun logIfDebug(tag: String, message: () -> String) {
    if (BuildConfig.DEBUG) {
        // 릴리즈 빌드에선 message() 자체를 호출 안 함
        // inline이 없으면 릴리즈 빌드에서도 message() 람다 객체가 생성됨
        Log.d(tag, message())
    }
}

// 클라이언트 코드
logIfDebug("Network") { "응답 데이터: ${response.body()}" } 


// 3. reified — 타입 안전한 JSON 파싱
inline fun <reified T> String.fromJson(): T {
    return Gson().fromJson(this, T::class.java)
}

// 클라이언트 코드
val user: User = jsonString.fromJson<User>()
val list: List<Item> = jsonString.fromJson<List<Item>>() // reified 없이는 제네릭 타입을 런타임에 알 수 없어서 T::class.java가 불가능


// 4. 트랜잭션 패턴
inline fun <T> db.transaction(block: () -> T): T {
    beginTransaction()
    return try {
        val result = block()
        setTransactionSuccessful()
        result
    } finally {
        endTransaction()
    }
}

// 사용
db.transaction {
    insertUser(user)
    updateProfile(profile)
}