package com.example.app  // 패키지 선언

class User { }
class Order { }  // 한 파일에 여러 클래스 가능

import com.example.util.StringHelper
import com.example.util.DateHelper as DH  // as로 별명 부여

fun main() {
    StringHelper.format("hello")
    DH.now()  // 별명으로 사용
}

val name: String = "홍길동"  // 읽기 전용, 재할당 불가
var age: Int = 25           // 변경 가능

age = 26       // OK
// name = "김철수"  // 컴파일 에러! val은 재할당 불가

var username: String = "Kildong"
//  ^^^^^^^^  ^^^^^^   ^^^^^^^^
//  변수이름   자료형      값

val name = "홍길동"    // String으로 추론
val age = 25          // Int로 추론
val pi = 3.14         // Double로 추론
val isActive = true   // Boolean으로 추론

val list = mutableListOf(1, 2, 3)
// list = mutableListOf(4, 5)  // 에러! 참조 변경 불가
list.add(4)                     // OK — 내부 상태 변경은 가능
println(list)                   // [1, 2, 3, 4]

val num: Int = 100
// 코드상으로는 참조형 Int이지만
// 컴파일 후 JVM 바이트코드에서는 기본형 int로 변환

val num1 = 100             // Int로 추론
val num2 = 2147483648      // Long으로 추론 (Int 범위 초과)
val num3 = 100L            // 접미사 L → Long 명시
val num4: Byte = 127       // 자료형 명시 필요 (기본 추론은 Int)
val num5: Short = 32767    // 자료형 명시 필요

// 다른 진법 표현
val hex = 0xFF             // 16진수 → 255
val bin = 0b10110110       // 2진수 → 182

val uByte: UByte = 255u
val uInt: UInt = 100u
val uLong: ULong = 100uL

val million = 1_000_000         // 1,000,000
val card = 1234_5678_9012_3456L
val hex = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001

val d1 = 3.14          // Double로 추론 (기본)
val f1 = 3.14F         // 접미사 F → Float 명시

// 지수 표기법
val sci1 = 3.14e2      // 314.0 (3.14 × 10²)
val sci2 = 3.14E-2     // 0.0314 (3.14 × 10⁻²)

val isActive: Boolean = true
val isAdmin = false   // Boolean으로 추론

// 논리 연산에 주로 사용
if (isActive && !isAdmin) {
    println("일반 활성 사용자")
}

val ch1: Char = 'A'
val ch2: Char = '가'
val ch3: Char = '\uAC00'  // 유니코드로 '가'

// 문자에 숫자 연산 가능
val next = ch1 + 1  // 'B'
println(next)        // B

val s1 = "Hello"
val s2 = "Hello"
val s3 = String("Hello".toCharArray())

println(s1 == s2)    // true  — 값(내용) 비교
println(s1 === s2)   // true  — 같은 String Pool 객체 참조
println(s1 === s3)   // false — 서로 다른 객체

val name = "홍길동"
val age = 25

// $ 기호로 변수 삽입
println("이름: $name")

// ${} 안에 표현식 사용
println("내년 나이: ${age + 1}")
println("이름 길이: ${name.length}")

val json = """
    {
        "name": "홍길동",
        "age": 25
    }
""".trimIndent()

println(json)

typealias Username = String
typealias Age = Int

val user: Username = "홍길동"
val userAge: Age = 25

typealias UserMap = Map<String, List<Pair<Int, String>>>

val data: UserMap = mapOf("team1" to listOf(1 to "홍길동", 2 to "김철수"))

var name: String = "홍길동"
// name = null  // 컴파일 에러! String은 null 불가

var nullableName: String? = "홍길동"
nullableName = null  // OK — String?은 null 허용

var str: String? = "Hello Kotlin"

println(str?.length)  // 12

str = null
println(str?.length)  // null (NPE 없이 안전하게 null 반환)

data class Address(val city: String?)
data class User(val name: String, val address: Address?)

val user: User? = User("홍길동", Address("서울"))

// 중첩된 nullable 접근도 안전하게
val city = user?.address?.city
println(city)  // "서울"

val noUser: User? = null
val noCity = noUser?.address?.city
println(noCity)  // null

var str: String? = null

// str이 null이면 -1 반환
val length = str?.length ?: -1
println(length)  // -1

// 위 코드는 아래와 동일
val length2 = if (str != null) str.length else -1

// 실용적인 활용
fun getDisplayName(user: User?): String {
    return user?.name ?: "익명 사용자"
}

// 조기 반환 패턴
fun process(input: String?) {
    val value = input ?: return  // null이면 함수 즉시 종료
    println("처리: $value")
}

var str: String? = "Hello"

println(str!!.length)  // 5 — null이 아니므로 정상 동작

str = null
// println(str!!.length)  // NPE 발생! 가능하면 사용하지 말 것

val a: Int = 100

// val b: Long = a     // 컴파일 에러! 암시적 변환 불가
val b: Long = a.toLong()  // 명시적 변환 필요

val intVal = 100
val doubleVal = intVal.toDouble()   // 100.0
val longVal = intVal.toLong()       // 100L

// 표현식에서는 큰 자료형으로 자동 변환
val result = 10 + 3.14   // Double로 자동 변환 → 13.14
val result2 = 10L + 3    // Long으로 자동 변환 → 13L

val a: Int = 128
val b: Int? = 128

println(a == b)    // true  — 값이 같음
println(a === b)   // false — a는 기본형(스택), b는 참조형(힙)

fun checkType(x: Any) {
    if (x is String) {
        // 이 블럭 안에서 x는 자동으로 String으로 캐스트됨
        println("문자열 길이: ${x.length}")  // x.length 바로 사용 가능
    }

    if (x is Int) {
        println("정수의 제곱: ${x * x}")
    }
}

checkType("Hello")   // 문자열 길이: 5
checkType(7)          // 정수의 제곱: 49

val obj: Any = "Hello Kotlin"

val str: String = obj as String     // 성공
println(str.length)                  // 12

// val num: Int = obj as Int         // ClassCastException!

// 안전한 캐스트: 실패하면 null 반환
val safeNum: Int? = obj as? Int
println(safeNum)                     // null (예외 없음)

var num: Number = 12.2   // Double
num = 12                  // Int로 스마트 캐스트
num = 120L                // Long으로 스마트 캐스트
num += 12.0f              // Float로 스마트 캐스트

fun printAnything(value: Any) {
    println("값: $value, 타입: ${value::class.simpleName}")
}

printAnything(42)        // 값: 42, 타입: Int
printAnything("Hello")   // 값: Hello, 타입: String
printAnything(3.14)      // 값: 3.14, 타입: Double

// 정수 나눗셈 주의
println(7 / 2)      // 3 (소수점 버림)
println(7.0 / 2)    // 3.5 (실수 나눗셈)
println(7 / 2.0)    // 3.5

var a = 10
val b = ++a   // a를 먼저 11로 만든 후 b에 대입
println("a=$a, b=$b")  // a=11, b=11

var c = 10
val d = c++   // d에 10을 먼저 대입한 후 c를 11로 만듦
println("c=$c, d=$d")  // c=11, d=10

val age = 25
val hasLicense = true

if (age >= 18 && hasLicense) {
    println("운전 가능")
}

val x = 0b1010  // 10
val y = 0b1100  // 12

println(x and y)     // 0b1000 = 8
println(x or y)      // 0b1110 = 14
println(x xor y)     // 0b0110 = 6
println(x.inv())     // 비트 반전

println(1 shl 3)     // 8  (1을 왼쪽으로 3칸 시프트)
println(16 shr 2)    // 4  (16을 오른쪽으로 2칸 시프트)