함수 기초 — 단일 표현식, 기본값 파라미터, 명명 인자

// 기본 형태
fun add(a: Int, b: Int): Int {
    return a + b
}

// 반환 타입이 Unit이면 생략 가능
fun greet(name: String) {
    println("안녕, $name")
}

// 일반 형태
fun double(x: Int): Int {
    return x * 2
}

// 단일 표현식 함수 — 반환 타입도 추론 가능
fun double(x: Int) = x * 2

// if 표현식도 가능
fun max(a: Int, b: Int) = if (a > b) a else b

// when 표현식도 가능
fun describe(obj: Any) = when (obj) {
    is Int -> "정수"
    is String -> "문자열"
    else -> "기타"
}

// 자바 — 오버로딩 세 개
public String greet(String name) { return greet(name, "안녕"); }
public String greet(String name, String greeting) { return greet(name, greeting, "!"); }
public String greet(String name, String greeting, String punctuation) {
    return greeting + ", " + name + punctuation;
}

// 코틀린 — 하나의 함수
fun greet(
    name: String,
    greeting: String = "안녕",
    punctuation: String = "!"
): String = "$greeting, $name$punctuation"

// 다양한 호출 방식
greet("코틀린")                        // "안녕, 코틀린!"
greet("코틀린", "반갑다")               // "반갑다, 코틀린!"
greet("코틀린", "반갑다", "~")          // "반갑다, 코틀린~"

@JvmOverloads
fun greet(
    name: String,
    greeting: String = "안녕",
    punctuation: String = "!"
): String = "$greeting, $name$punctuation"

fun createUser(
    name: String,
    age: Int,
    email: String = "",
    isAdmin: Boolean = false
): String = "$name($age)"

// 명명 인자 사용
createUser(name = "홍길동", age = 25)
createUser(age = 30, name = "김철수")                 // 순서 변경 가능
createUser(name = "박지은", age = 28, isAdmin = true) // 중간 파라미터 건너뛰기

// 이름 없이 호출하면 무슨 의미인지 알기 어려움
sendEmail("hello@test.com", "제목", true, false, 3)

// 명명 인자로 호출하면 의미가 명확
sendEmail(
    to = "hello@test.com",
    subject = "제목",
    isHtml = true,
    hasAttachment = false,
    retryCount = 3
)

fun printAll(vararg messages: String) {
    for (msg in messages) {
        println(msg)
    }
}

printAll("안녕", "하세요", "코틀린")

val words = arrayOf("Hello", "World")
printAll(*words)                          // spread 연산자로 풀어서 전달
printAll("Hi", *words, "Kotlin")          // 다른 인자와 섞어서 사용 가능

fun format(vararg parts: String, separator: String = ", "): String {
    return parts.joinToString(separator)
}

format("사과", "바나나", "체리")                      // "사과, 바나나, 체리"
format("사과", "바나나", separator = " | ")            // "사과 | 바나나"

fun processUser(user: User) {
    // 지역 함수 — 바깥 함수의 파라미터에 접근 가능
    fun validate() {
        require(user.name.isNotBlank()) { "이름이 비어있습니다" }
        require(user.age > 0) { "나이는 양수여야 합니다" }
    }

    validate()  // 검증 로직 호출
    // ... 나머지 처리
}

// to도 사실 infix 함수다
val pair = "이름" to "코틀린"   // Pair("이름", "코틀린")

// 직접 정의하기
infix fun Int.times(str: String) = str.repeat(this)

println(3 times "코틀린! ")  // "코틀린! 코틀린! 코틀린! "

// 가독성 있는 DSL 만들기
infix fun <T> T.shouldBe(expected: T) {
    if (this != expected) {
        throw AssertionError("기대값: $expected, 실제값: $this")
    }
}

// 테스트 코드에서 활용
val result = calculator.add(2, 3)
result shouldBe 5   // 읽기 쉬운 테스트

// 일반 재귀 — 깊은 호출 시 StackOverflow 위험
fun factorial(n: Long): Long {
    if (n <= 1) return 1
    return n * factorial(n - 1)   // 재귀 호출 후 곱셈이 남아 있음
}

// 꼬리 재귀 — 컴파일러가 반복문으로 변환
tailrec fun factorialTailrec(n: Long, acc: Long = 1): Long {
    if (n <= 1) return acc
    return factorialTailrec(n - 1, n * acc)  // 재귀 호출이 마지막 연산
}

// tailrec 가능 — 재귀 호출이 마지막
tailrec fun findFixedPoint(x: Double = 1.0): Double =
    if (Math.abs(x - Math.cos(x)) < 1e-10) x
    else findFixedPoint(Math.cos(x))

// tailrec 불가 — 재귀 호출 후 + 1 연산이 남아 있음
// tailrec fun bad(n: Int): Int = if (n == 0) 0 else bad(n - 1) + 1

// 리스트에서 특정 조건을 만족하는 첫 번째 요소 찾기
tailrec fun <T> findFirst(
    list: List<T>,
    index: Int = 0,
    predicate: (T) -> Boolean
): T? {
    if (index >= list.size) return null
    if (predicate(list[index])) return list[index]
    return findFirst(list, index + 1, predicate)
}

// GCD (최대공약수) 계산
tailrec fun gcd(a: Int, b: Int): Int =
    if (b == 0) a else gcd(b, a % b)

// 함수 타입 — (파라미터 타입) -> 반환 타입
val double: (Int) -> Int = { it * 2 }
val isPositive: (Int) -> Boolean = { it > 0 }

// 함수를 파라미터로 받기
fun applyOperation(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

println(applyOperation(5, double))     // 10
println(applyOperation(5) { it * 3 })  // 15 — 트레일링 람다