val x = 3

val result = x match {
  case 1 => "one"
  case 2 => "two"
  case 3 => "three"
  case _ => "other"  // 와일드카드 (기본값)
}
println(result)  // three

def describe(x: Any): String = x match {
  case 0     => "영"
  case true  => "참"
  case "hi"  => "인사"
  case null  => "널"
  case _     => "기타"
}

val x = 42

x match {
  case n => println(s"값은 $n")  // n에 x가 바인딩됨
}

// 주의: 변수 이름이 소문자로 시작하면 변수 패턴
// 대문자로 시작하면 상수 참조
val One = 1
val two = 2

x match {
  case One => "상수 One과 매칭"
  case two => "모든 값과 매칭됨 (변수 패턴)"
  // case `two` => "백틱으로 상수로 취급"
}

def describe(x: Any): String = x match {
  case i: Int       => s"정수: $i"
  case s: String    => s"문자열: $s (길이: ${s.length})"
  case d: Double    => s"실수: $d"
  case l: List[_]   => s"리스트 (길이: ${l.length})"
  case _            => "알 수 없는 타입"
}

println(describe(42))          // 정수: 42
println(describe("hello"))     // 문자열: hello (길이: 5)
println(describe(List(1,2,3))) // 리스트 (길이: 3)

val pair = (1, "one")

pair match {
  case (1, s)    => s"일: $s"
  case (2, s)    => s"이: $s"
  case (n, s)    => s"$n: $s"
}

// 중첩 튜플
val nested = ((1, 2), (3, 4))
nested match {
  case ((a, b), (c, d)) => s"$a, $b, $c, $d"
}

case class Person(name: String, age: Int)
case class Address(city: String, zipCode: String)
case class Employee(person: Person, address: Address)

val emp = Employee(Person("김철수", 30), Address("서울", "12345"))

emp match {
  case Employee(Person(name, age), Address(city, _)) =>
    s"$name ($age세), $city 거주"
}

val list = List(1, 2, 3, 4, 5)

list match {
  case Nil            => "빈 리스트"
  case head :: Nil    => s"원소 하나: $head"
  case head :: tail   => s"첫 번째: $head, 나머지: $tail"
}

// 특정 패턴
list match {
  case List(1, 2, _*) => "1, 2로 시작"  // Scala 3
  // case List(1, 2, _*) => "1, 2로 시작"  // Scala 2도 동일
  case _              => "다른 패턴"
}

// 길이 체크
list match {
  case List(a)          => s"원소 1개: $a"
  case List(a, b)       => s"원소 2개: $a, $b"
  case List(a, b, c)    => s"원소 3개: $a, $b, $c"
  case _ :: _ :: _ :: _ => "원소 4개 이상"
  case _                => "빈 리스트"
}

val day = "Monday"

day match {
  case "Saturday" | "Sunday" => "주말"
  case _                     => "평일"
}

// 숫자
val n = 5
n match {
  case 1 | 2 | 3 => "작은 수"
  case 4 | 5 | 6 => "중간 수"
  case _         => "큰 수"
}

def classify(n: Int): String = n match {
  case x if x < 0   => "음수"
  case x if x == 0  => "영"
  case x if x < 10  => "한 자리 양수"
  case x if x < 100 => "두 자리 양수"
  case _            => "세 자리 이상"
}

// 케이스 클래스와 함께
case class Person(name: String, age: Int)

def describe(p: Person): String = p match {
  case Person(_, age) if age < 0   => "잘못된 나이"
  case Person(name, _) if name.isEmpty => "이름 없음"
  case Person(name, age) if age < 18 => s"$name 은(는) 미성년자"
  case Person(name, age)             => s"$name 은(는) 성인"
}

case class Person(name: String, age: Int)

val person = Person("Alice", 30)

person match {
  case p @ Person(_, age) if age >= 18 =>
    println(s"성인: $p")  // 전체 Person 객체 사용
  case _ =>
    println("미성년자")
}

// 리스트에서 활용
List(1, 2, 3) match {
  case all @ (first :: rest) =>
    println(s"전체: $all, 첫 번째: $first, 나머지: $rest")
  case _ =>
    println("빈 리스트")
}

object Even {
  def unapply(n: Int): Boolean = n % 2 == 0
}

object Odd {
  def unapply(n: Int): Boolean = n % 2 != 0
}

42 match {
  case Even() => "짝수"
  case Odd()  => "홀수"
}

// 값을 추출하는 추출자
object Email {
  def unapply(email: String): Option[(String, String)] = {
    val parts = email.split("@")
    if (parts.length == 2) Some((parts(0), parts(1)))
    else None
  }
}

"user@example.com" match {
  case Email(user, domain) => s"사용자: $user, 도메인: $domain"
  case _ => "유효하지 않은 이메일"
}

import scala.annotation.switch

// 컴파일러가 점프 테이블 생성을 보장
def dayOfWeek(n: Int): String = (n: @switch) match
  case 1 => "월"
  case 2 => "화"
  case 3 => "수"
  case 4 => "목"
  case 5 => "금"
  case 6 => "토"
  case 7 => "일"
  case _ => "?"

// 타입에 따라 반환 타입이 결정됨
type Elem[X] = X match
  case String      => Char
  case Array[t]    => t
  case Iterable[t] => t

// 컴파일 타임에 타입이 결정됨
val char: Elem[String] = 'a'        // Char
val int: Elem[Array[Int]] = 1       // Int
val str: Elem[List[String]] = "hi"  // String

val (a, b) = (1, 2)
val Person(name, age) = Person("Alice", 30)
val head :: tail = List(1, 2, 3)

val pairs = List((1, "one"), (2, "two"), (3, "three"))

for ((num, str) <- pairs) {
  println(s"$num = $str")
}

// Option 필터링
val maybeValues = List(Some(1), None, Some(3))
for (Some(x) <- maybeValues) {
  println(x)  // 1, 3 (None은 건너뜀)
}

try {
  // 위험한 코드
} catch {
  case e: NumberFormatException => "숫자 형식 오류"
  case e: IllegalArgumentException => "잘못된 인자"
  case e: Exception => s"기타 오류: ${e.getMessage}"
}

val divide: PartialFunction[(Int, Int), Int] = {
  case (a, b) if b != 0 => a / b
}

println(divide.isDefinedAt((10, 2)))  // true
println(divide.isDefinedAt((10, 0)))  // false
println(divide((10, 2)))              // 5

// collect에서 활용
val pairs = List((10, 2), (20, 0), (30, 3))
val results = pairs.collect {
  case (a, b) if b != 0 => a / b
}
println(results)  // List(5, 10)

sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color

// 경고: match may not be exhaustive
def describe(c: Color): String = c match {
  case Red   => "빨강"
  case Green => "초록"
  // Blue 누락 - 경고!
}

// @unchecked로 경고 억제 (권장하지 않음)
def describe2(c: Color): String = (c: @unchecked) match {
  case Red => "빨강"
}

// 1. match 대신 isInstanceOf/asInstanceOf 사용
def process(x: Any): String = {
  if (x.isInstanceOf[Int]) x.asInstanceOf[Int].toString
  else if (x.isInstanceOf[String]) x.asInstanceOf[String]
  else "unknown"
}  // 타입 안전하지 않음!

// 2. 와일드카드 패턴이 먼저 오는 경우
x match {
  case _ => "default"     // 항상 매칭됨!
  case n: Int => n.toString  // 도달 불가 코드
}

// 3. Option에서 get 사용
val opt: Option[Int] = Some(5)
opt.get  // None이면 NoSuchElementException!

// 4. 불완전한 패턴 매칭 (sealed 타입)
sealed trait Color
case object Red extends Color
case object Blue extends Color

def name(c: Color) = c match {
  case Red => "red"
  // Blue 누락 - 런타임 에러 가능!
}

// 1. 패턴 매칭 사용
def process(x: Any): String = x match {
  case n: Int => n.toString
  case s: String => s
  case _ => "unknown"
}

// 2. 구체적인 패턴을 먼저
x match {
  case n: Int => n.toString
  case _ => "default"
}

// 3. 패턴 매칭이나 getOrElse 사용
opt match {
  case Some(n) => n.toString
  case None => "default"
}
// 또는
opt.getOrElse(0)
opt.fold("default")(_.toString)

// 4. 모든 케이스 처리
def name(c: Color) = c match {
  case Red => "red"
  case Blue => "blue"  // 완전한 매칭
}