// 코틀린 프로그램의 진입점은 무조건 main 함수입니다.
// 자바처럼 억지로 class Main { ... } 포장지를 만들 필요가 없습니다. (Top-level 함수)
// 함수를 선언할 때는 function의 약자인 'fun' 키워드를 사용합니다.
fun main() {
    
    // System.out.println() 대신 아주 간결한 println()을 지원합니다.
    println("Hello, Kotlin World!")
    
    // 문장이 끝날 때 세미콜론(;)을 붙이지 않아도 됩니다!
    println("코틀린은 자바보다 간결합니다.")
}

fun main() {
    // 1. val: 불변 변수 (Read-only, Value)
    // 우측의 값(5000)을 보고 자동으로 정수(Int) 타입으로 똑똑하게 '추론'합니다.
    val popcornPrice = 5000 
    
    // popcornPrice = 6000 // (에러!) val로 선언된 변수는 자물쇠가 채워져 값을 절대 변경할 수 없습니다.

    // 2. var: 가변 변수 (Mutable, Variable)
    var ticketCount = 2
    println("현재 티켓 수: " + ticketCount)
    
    ticketCount = 3 // 뚜껑이 열려있는 상자이므로 값 변경이 자유롭습니다.
    println("변경 후 티켓 수: " + ticketCount)

    // 3. 명시적으로 타입을 선언할 수도 있습니다. (변수명: 타입)
    val movieName: String = "인터스텔라"
    val rating: Double = 9.8

    // 4. 문자열 템플릿 ($ 기호)
    // 자바처럼 번거롭게 + 기호로 변수를 이어 붙일 필요 없이, 문자열 안에 바로 변수명을 적어줍니다.
    println("영화명: $movieName, 평점: $rating, 티켓 수: $ticketCount")
}

fun main() {
    // 1. List (순서 보장, 중복 허용)
    // 읽기 전용(Immutable) 리스트
    val readOnlyList = listOf("Apple", "Banana", "Cherry")
    println("읽기 전용: " + readOnlyList)
    
    // readOnlyList.add("Orange") 
    // 컴파일 에러! listOf로 만들면 add(), remove() 같은 메서드 자체가 존재하지 않습니다.

    // 가변(Mutable) 리스트
    val mutableList = mutableListOf("Apple", "Banana")
    mutableList.add("Cherry") // 추가 가능!
    println("수정 가능: " + mutableList)


    // 2. Map (Key-Value 쌍)
    // 'to' 라는 특별한 키워드(중위 연산자)를 사용하여 매우 직관적으로 키-값 쌍을 연결합니다.
    val menuPrices = mutableMapOf(
        "아메리카노" to 4000,
        "카페라떼" to 4500
    )
    
    // 값을 추가하거나 읽을 때 자바의 put(), get() 대신 
    // 마치 배열을 다루듯 대괄호[]를 사용할 수 있습니다.
    menuPrices["바닐라라떼"] = 5000 // 값 추가
    println("아메리카노 가격: " + menuPrices["아메리카노"]) // 값 읽기
}

fun main() {
    // 1. 표현식(Expression)으로서의 if
    val a = 10
    val b = 20
    
    // 코틀린에서는 삼항 연산자( a > b ? a : b )가 없는 대신, 
    // if문 전체의 마지막 줄 결과가 변수에 그대로 대입됩니다!
    val max = if (a > b) {
        println("a가 큽니다.")
        a // <- 이 값이 리턴됨
    } else {
        println("b가 크거나 같습니다.")
        b // <- 이 값이 리턴됨
    }
    println("최대값: $max")

    // 2. 강력하고 안전한 when 표현식 (switch의 완벽한 진화)
    val score = 85
    val grade = when {
        score >= 90 -> "A" // "조건 -> 결과" 문법 사용 (break 불필요!)
        score >= 80 -> "B"
        score >= 70 -> "C"
        else -> "F"        // when 결과를 변수에 담을 때는 모든 경우의 수를 커버해야 에러가 안 납니다.
    }
    println("당신의 학점은 $grade 입니다.")

    // 3. 값, 타입 매칭 등 무엇이든 검사하는 when
    val obj: Any = "Hello" // Any는 자바의 Object와 같습니다.
    when (obj) {
        1 -> println("숫자 1입니다.")
        "Hello" -> println("인삿말입니다.")
        is String -> println("문자열 타입입니다.") // 타입 확인도 is 로 곧바로 가능!
        else -> println("기타 등등")
    }
}

// 1. 기본 함수 선언 (파라미터명: 타입): 반환타입
// 자바의 메서드와 구조가 비슷하지만 'fun' 키워드를 사용하고 반환타입이 뒤에 붙습니다.
fun sum(a: Int, b: Int): Int {
    return a + b
}

// 2. 단일 표현식 함수 (Single Expression Function)
// 함수 안의 로직이 단 한 줄이라면, 중괄호{}와 return 키워드를 없애고 
// 등호(=)를 써서 극도로 짧게 줄일 수 있습니다! (반환타입도 추론되므로 생략 가능)
fun multiply(a: Int, b: Int) = a * b

// 3. 기본값을 갖는 매개변수 (Default Arguments)
// 호출자가 message를 넘기지 않으면, 기본값인 "안녕하세요"가 자동으로 들어갑니다.
// 자바처럼 메서드 오버로딩을 여러 개 만들 필요가 없습니다!
fun greet(name: String, message: String = "안녕하세요") {
    println("$name 님, $message")
}

fun main() {
    println("합계: " + sum(10, 20))
    println("곱셈: " + multiply(5, 4))
    
    // 파라미터 1개만 던짐 -> 나머지 하나는 Default 값이 작동!
    greet("홍길동") 
    
    // 4. 이름 붙인 인자 (Named Arguments)
    // 파라미터가 5~6개 넘어갈 때, 순서를 외울 필요 없이 변수명을 직접 지정해서 던집니다.
    // 심지어 순서를 바꿔치기 해도 아무 문제 없이 작동합니다.
    greet(message = "반갑습니다", name = "이순신")
}

// 주 생성자(Primary Constructor)를 이용한 초간단 클래스 선언
// 클래스 이름 옆의 괄호가 주 생성자 역할을 하며, val/var를 붙이면 해당 변수들은
// 내부 필드로 선언됨과 동시에 Getter(val의 경우)와 Setter(var의 경우)까지 자동 완성됩니다!
class Person(val name: String, var age: Int) {
    
    // 인스턴스가 생성될 때 제일 먼저 실행되는 초기화 블록
    init {
        println("새로운 사람(${name})이 생성되었습니다.")
    }

    // 멤버 함수
    fun introduce() {
        println("제 이름은 $name 이고 나이는 $age 입니다.")
    }
}

fun main() {
    // 1. 객체 생성 시 자바의 거추장스러운 'new' 키워드를 쓰지 않습니다!
    // 마치 함수를 호출하듯 아주 자연스럽게 객체를 만듭니다.
    val p1 = Person("Alice", 25)
    
    p1.introduce()
    
    // 2. 프로퍼티 접근 방식
    // 코틀린은 p1.getName(), p1.setAge() 같은 메서드를 직접 부르지 않습니다.
    // 마침표(.)를 찍어 필드에 직접 접근하듯 코드를 작성하면, 
    // 코틀린 컴파일러가 알아서 내부적으로 Getter와 Setter를 호출해 줍니다.
    println("이름 읽기: " + p1.name)    // 내부적으로 p1.getName() 호출
    
    p1.age = 26                      // 내부적으로 p1.setAge(26) 호출
    println("나이 증가: " + p1.age)
}

fun main() {
    // 1. 코틀린의 기본 타입은 절대 null을 가질 수 없는 'Non-Null' 타입입니다.
    var nonNullString: String = "Hello"
    // nonNullString = null // (컴파일 에러!) 폭탄 자체를 들이지 못하게 막습니다.

    // 2. Nullable 타입 (타입명 뒤에 ?)
    // 정말로 null이 필요하다면 타입 뒤에 물음표를 붙여 허락을 받아야 합니다.
    var nullableString: String? = "Kotlin"
    nullableString = null // 정상적으로 null 대입 가능
    
    // 3. 안전한 호출 연산자 (?.)
    // 변수가 null 일지도 모르는 상태에서 강제로 메서드(length)를 호출하면 원래 NPE가 터집니다.
    // 하지만 ?. 를 쓰면 "null이면 뒤의 length를 실행하지 말고 그냥 null을 리턴해라"가 됩니다.
    val length = nullableString?.length
    println("문자열의 길이는? " + length) // 런타임 에러 없이 null 이 출력됨

    // 4. 엘비스 연산자 (?:) - 기호 모양이 엘비스 프레슬리 머리를 닮아 붙여진 이름
    // null이 떨어졌을 때, 프로그램 로직 상 null을 계속 끌고 가기보다 
    // 기본값(0)으로 안전하게 교체하고 싶을 때 사용합니다.
    val safeLength = nullableString?.length ?: 0
    println("안전한 문자열의 길이는? " + safeLength) // null 대신 0 이 출력됨
}

// String 클래스에 나만의 커스텀 함수(removeFirstLast)를 갖다 붙입니다.
// 수신 객체 타입(이 경우 String)에 마침표를 찍고 내가 원하는 함수명을 정의합니다.
// 함수 내부에서 쓰이는 'this' 키워드는 이 함수를 호출하는 대상 문자열 자체를 가리킵니다.
fun String.removeFirstLast(): String {
    // 길이가 2보다 작으면 양 끝을 자를 수 없으니 그냥 원본을 반환
    if (this.length <= 2) return this
    
    // 첫 번째 글자(인덱스 1)부터 맨 마지막 글자 직전(length - 1)까지 자름
    return this.substring(1, this.length - 1)
}

fun main() {
    val myText = "Hello Kotlin"
    
    // 원래 String 클래스에 내장되어 있던 기본 메서드인 것처럼, 
    // 마침표(.)를 찍고 아주 자연스럽게 호출 가능! 
    val result = myText.removeFirstLast()
    
    println("원본: " + myText)
    println("확장 함수 적용 결과: " + result) // 앞뒤 H와 n이 잘린 "ello Kotli" 출력
}

class Robot(var name: String, var battery: Int) {
    fun status() = "이름: $name, 배터리: $battery%"
}

fun main() {
    // 1. apply: 객체 생성과 동시에 초기화 셋팅을 할 때 가장 많이 쓰입니다. 
    // 블록 안에서는 'this'로 접근하기 때문에 this를 생략하고 곧바로 필드명을 쓸 수 있습니다.
    // 셋팅이 끝난 후에는 셋팅 완료된 객체 자신(r1)을 반환합니다.
    val r1 = Robot("R2D2", 10).apply {
        battery = 100     // this.battery = 100 과 동일
        name = "Super R2D2" // this.name = "Super R2D2" 과 동일
    }
    println(r1.status())

    // 2. let: 안전한 호출(?.)과 함께 연계하여 값이 null이 아닐 때만 블록을 실행할 때 주로 쓰입니다.
    // 블록 안에서는 'it' 키워드로 객체에 접근합니다.
    var nullableName: String? = "Kotlin"
    
    val lengthMessage = nullableName?.let {
        println("문자열 $it 이(가) null이 아닙니다!")
        "길이는 ${it.length} 입니다." // 블록의 가장 마지막 줄 수식 결과가 반환되어 lengthMessage에 들어갑니다.
    }
    println(lengthMessage)
}

// 1. 고차 함수 (Higher-Order Function) 선언
// 세 번째 파라미터 'action'은 (Int, Int)를 받아서 Int를 반환하는 '함수 타입'을 요구합니다.
fun calculate(a: Int, b: Int, action: (Int, Int) -> Int): Int {
    // 뼈대 기계가 작동하다가, 외부에서 주입받은 함수(배터리)를 여기서 실행시킵니다.
    val result = action(a, b) 
    return result
}

fun main() {
    // 2. 람다식을 변수에 저장하기
    // 함수를 숫자나 문자열처럼 변수 sumLambda 에 저장합니다.
    val sumLambda: (Int, Int) -> Int = { x, y -> x + y }
    
    // 저장된 함수를 다른 함수의 파라미터로 넘겨줍니다.
    println("람다 변수 테스트: " + calculate(10, 5, sumLambda))

    // 3. 트레일링 람다 (Trailing Lambda)의 미학
    // calculate의 마지막 파라미터가 '함수'이기 때문에, 소괄호()를 닫아버리고
    // 그 뒤에 중괄호{}를 열어서 코드를 작성할 수 있습니다. 
    // (코틀린의 가독성을 극대화시키는 아주 중요한 문법입니다!)
    val multiResult = calculate(10, 5) { x, y -> 
        x * y // 람다 블록의 가장 마지막 줄이 함수의 반환값이 됩니다.
    }
    println("트레일링 람다(곱셈): " + multiResult)
}

// 1. 인터페이스 정의
// 자바와 달리 프로퍼티(val maxSpeed)를 추상화할 수 있습니다.
interface Flyable {
    val maxSpeed: Int 
    
    fun fly() // 추상 메서드
    
    // 본문이 있는 디폴트 메서드도 인터페이스에 작성 가능
    fun landing() { 
        println("안전하게 착륙합니다.")
    }
}

// 2. 상속을 허용하는 open 클래스
// 코틀린 클래스는 기본이 final이므로, 부모가 되려면 반드시 'open'을 써야 합니다.
// 메서드 역시 오버라이딩을 허용하려면 'open'을 붙여야 합니다.
open class Animal(val name: String) {
    open fun makeSound() {
        println("$name 가 소리를 냅니다.")
    }
}

// 3. 상속과 인터페이스 다중 구현
// 자바의 extends, implements 대신 콜론( : ) 하나로 통일합니다.
// Animal은 클래스이므로 생성자()를 호출해야 하고, Flyable은 인터페이스이므로 이름만 적습니다.
class Bird(name: String, override val maxSpeed: Int) : Animal(name), Flyable {
    
    // 자바의 @Override 어노테이션 대신, 코틀린은 override라는 '키워드'를 강제합니다.
    override fun makeSound() {
        println("짹짹!")
    }

    override fun fly() {
        println("$name 가 최대 속도 $maxSpeed 로 하늘을 납니다!")
    }
}

fun main() {
    val sparrow = Bird("참새", 50)
    sparrow.makeSound()
    sparrow.fly()
    sparrow.landing() // 인터페이스에 구현된 디폴트 메서드 호출
}

// 1. 싱글톤 선언 (object)
// class 대신 object 키워드를 쓰면, 메모리 상에 딱 1개만 존재하는 싱글톤 객체가 즉시 생성됩니다.
object DataBaseManager {
    var isConnected = false
    fun connect() {
        isConnected = true
        println("데이터베이스에 연결되었습니다!")
    }
}

// 2. 동반 객체 (Companion Object)
class User(val name: String) {
    // 코틀린에는 static 키워드가 없습니다. 
    // 대신 클래스 안에 companion object를 두어 자바의 static 영역처럼 사용합니다.
    companion object {
        val MAX_AGE = 120 // 공통 상수 (Java의 static final)
        
        // 팩토리 메서드 (Java의 static 메서드)
        fun createGuest(): User {
            return User("Guest_001")
        }
    }
}

fun main() {
    // object는 인스턴스를 생성할 필요가 없습니다. 이름 그 자체로 바로 접근합니다.
    DataBaseManager.connect()
    println("연결 상태: " + DataBaseManager.isConnected)

    // companion object 내부에 있는 멤버는 소속 클래스의 이름으로 직접 접근합니다.
    println("사람의 최대 수명 한계: " + User.MAX_AGE)
    
    val guest = User.createGuest()
    println("환영합니다, " + guest.name)
}

// 1. 데이터 클래스 (Data Class)
// 네트워크 요청 결과나 DB 데이터를 담는 껍데기(DTO)로 씁니다.
// toString(), equals(), hashCode(), copy() 가 모두 자동 생성됩니다!
data class UserDto(val id: Int, val username: String, var email: String)

// 2. 봉인 클래스 (Sealed Class)
// 상속받는 자식들을 동일한 패키지(혹은 파일) 내로 강제 제한하여, "자식의 종류는 이것뿐이야!" 라고 확정 짓습니다.
sealed class NetworkResult {
    data class Success(val data: String) : NetworkResult()
    data class Error(val exceptionMsg: String) : NetworkResult()
    object Loading : NetworkResult() // 데이터가 없는 상태만 나타낼 땐 object 사용
}

fun main() {
    // === Data Class 활용 ===
    val user1 = UserDto(1, "alice", "alice@test.com")
    val user2 = UserDto(1, "alice", "alice@test.com")
    
    // toString()이 예쁘게 오버라이딩 되어 필드값들이 모두 출력됨
    println(user1) 
    
    // equals()가 주소가 아닌 '내부 값'들을 비교하도록 오버라이딩 되어 있음
    println("두 유저가 같은가? " + (user1 == user2)) // true 출력!
    
    // 불변성을 지키기 위해, 일부 값만 바꾸면서 똑같은 구조의 새 객체를 복제할 수 있습니다.
    val user3 = user1.copy(id = 2, username = "bob")
    println(user3)

    // === Sealed Class 와 when 식의 찰떡 궁합 ===
    // 자식의 종류가 3개뿐이라는 것을 컴파일러가 완벽히 알고 있으므로 else 블록을 적을 필요가 없습니다.
    val response: NetworkResult = NetworkResult.Success("서버 응답 데이터")
    
    when (response) {
        is NetworkResult.Success -> println("성공: " + response.data)
        is NetworkResult.Error -> println("실패: " + response.exceptionMsg)
        NetworkResult.Loading -> println("로딩 중...")
    }
}

class Rectangle(var width: Int, var height: Int) {
    // 1. 커스텀 Getter
    // 필드처럼 보이지만, 읽을 때마다(get) 매번 계산식이 실행되어 값을 반환합니다.
    val isSquare: Boolean
        get() = (width == height)

    val area: Int
        get() = width * height
}

class Profile {
    // 2. lateinit: 객체를 미리 선언은 해야 하지만 지금 당장 값을 넣을 수 없을 때 씁니다.
    // 안드로이드의 뷰(View) 바인딩 등에서 필수적으로 사용됩니다. (null을 피하기 위한 궁여지책)
    lateinit var nickname: String

    // 3. lazy: 프로그램이 시작될 때 미리 만들어두면 메모리와 시간이 아까운 무거운 데이터를 다룰 때 씁니다.
    // 'heavyData'가 코드 상에서 최초로 불려지는 순간, 딱 1번만 중괄호 안의 코드가 실행됩니다.
    val heavyData: String by lazy {
        println("=> 복잡하고 오래 걸리는 데이터 로딩 중...")
        "거대한 용량의 데이터셋"
    }
}

fun main() {
    val rect = Rectangle(10, 10)
    println("정사각형인가? " + rect.isSquare) // true
    println("면적: " + rect.area)           // 100

    val p = Profile()
    // 만약 여기서 닉네임을 할당하기 전에 println(p.nickname)을 부르면 크래시가 납니다!
    // lateinit 은 개발자가 책임지고 쓰기 전에 할당하겠다는 약속입니다.
    p.nickname = "코틀린러버"
    println("설정된 닉네임: " + p.nickname)

    // lazy 동작 확인
    println("lazy 데이터는 아직 로딩 안 됨.")
    
    // 아래에서 처음으로 heavyData를 부르는 순간, lazy 블록이 실행되어 로그가 찍힙니다.
    println("1차 호출: " + p.heavyData) 
    
    // 두 번째 부를 땐 로직을 다시 실행하지 않고, 메모리에 저장해둔 결과값만 빠르게 리턴합니다.
    println("2차 호출: " + p.heavyData) 
}

fun printLength(obj: Any) {
    // 매개변수 obj는 코틀린의 최상위 부모 타입인 'Any' 이므로, 기본적으로 length 프로퍼티를 쓸 수 없습니다.
    
    // 1. 스마트 캐스트 (is 연산자 활용)
    if (obj is String) {
        // 코틀린 컴파일러는 천재적입니다. 
        // 여기서 "아, obj는 확실하게 String이구나!" 라고 판단하고
        // 자바처럼 (String) obj 처럼 수동 캐스팅을 할 필요 없이 바로 length를 꺼내게 해줍니다.
        println("문자열 길이: " + obj.length) 
    } else {
        println("문자열이 아닙니다.")
    }
}

fun printNotNull(str: String?) {
    // str은 Nullable(물음표가 붙음)이므로 곧바로 length를 부르면 에러가 납니다.
    
    // 하지만 if문을 통해 null이 아님을 확실하게 증명했다면?
    if (str != null) {
        // 이 블록 안에서는 자동으로 Non-Null (일반 String)로 스마트 캐스트 됩니다!
        println("안전한 길이: " + str.length)
    }
}

fun main() {
    printLength("안녕하세요") // 문자열을 보냄
    printLength(12345)      // 정수를 보냄
    
    printNotNull("코틀린")

    // 2. 단언 연산자 (!!) - 극도로 주의!
    var danger: String? = "값"
    
    // "이건 null이 절대 아니니까 컴파일러야 묻지 말고 그냥 벗겨!" 라고 강제하는 명령입니다.
    // 임시방편으로 쓸 수는 있지만, 만약 진짜 null이었다면 바로 앱이 튕깁니다.
    println(danger!!.length) 
}

data class User(val name: String, val age: Int, val city: String)

fun main() {
    val users = listOf(
        User("Alice", 25, "Seoul"),
        User("Bob", 30, "Busan"),
        User("Charlie", 25, "Seoul"),
        User("David", 40, "Jeju")
    )

    // 1. filter 와 map 체이닝 (파이프라인)
    // - filter: 나이가 30 이상인 사람만 통과시킴
    // - map: 통과한 사람 객체에서 '이름(name)'만 쏙 빼서 새 리스트로 만듦
    val over30Names = users.filter { it.age >= 30 }.map { it.name }
    println("30세 이상 이름: " + over30Names)

    // 2. groupBy (SQL의 GROUP BY와 완벽히 동일)
    // 도시(city) 이름을 Key로 삼아 해당하는 유저들을 그룹으로 묶은 Map을 반환합니다.
    val usersByCity: Map<String, List<User>> = users.groupBy { it.city }
    // 서울을 Key로 갖는 리스트의 크기(size)를 구합니다.
    println("Seoul 유저 수: " + usersByCity["Seoul"]?.size + "명")

    // 3. maxByOrNull, minByOrNull
    // 나이(age)를 기준으로 순회를 돌며 가장 수치가 높은 유저 객체 1개를 리턴합니다.
    val oldest = users.maxByOrNull { it.age }
    println("가장 나이 많은 사람: " + oldest?.name)

    // 4. any, all, none (Boolean 리턴 함수들)
    val hasSeoul = users.any { it.city == "Seoul" } // 서울 사는 사람이 하나라도 있는가? (true)
    val allAdults = users.all { it.age >= 18 }      // 싹 다 18세 이상인가? (true)
    
    println("서울 거주자 존재? " + hasSeoul)
    println("모두 성인인가? " + allAdults)
}