// 常量匹配
def describe(x: Any): String = x match {
    case 0 => "zero"
    case 1 => "one"
    case "hello" => "greeting"
    case true => "truth"
    case _ => "something else"
}

// 类型匹配
def typeOf(x: Any): String = x match {
    case s: String => s"String: $s"
    case i: Int => s"Int: $i"
    case d: Double => s"Double: $d"
    case list: List[_] => s"List of ${list.size} elements"
    case _ => "unknown"
}

// 带守卫的模式
def classify(n: Int): String = n match {
    case x if x < 0 => "negative"
    case 0 => "zero"
    case x if x > 0 && x <= 10 => "small positive"
    case x if x > 10 => "large positive"
}

// 列表模式
val list = List(1, 2, 3, 4, 5)
list match {
    case Nil => "empty"
    case head :: tail => s"head: $head, tail: $tail"
    case List(1, 2, _*) => "starts with 1, 2"
    case List(_, _, x, _*) => s"third element: $x"
}

// 元组模式
val point = (3, 4)
point match {
    case (0, 0) => "origin"
    case (x, 0) => s"on x-axis at $x"
    case (0, y) => s"on y-axis at $y"
    case (x, y) => s"at ($x, $y)"
}

// case 类模式
sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape

def area(shape: Shape): Double = shape match {
    case Circle(r) => math.Pi * r * r
    case Rectangle(w, h) => w * h
}

// 自定义提取器
object Email {
    def unapply(str: String): Option[(String, String)] = {
        val parts = str.split("@")
        if (parts.length == 2) Some((parts(0), parts(1)))
        else None
    }
}

// 使用
"alice@example.com" match {
    case Email(user, domain) => println(s"User: $user, Domain: $domain")
    case _ => println("Not an email")
}

// 变量提取器
object Twice {
    def apply(s: String): String = s + s
    def unapply(s: String): Option[String] = {
        val length = s.length / 2
        if (length * 2 == s.length && s.substring(0, length) == s.substring(length))
            Some(s.substring(0, length))
        else None
    }
}

"abcabc" match {
    case Twice(x) => println(s"Repeated: $x")  // Repeated: abc
    case _ => println("Not repeated")
}

sealed trait JsonValue
case class JsonString(value: String) extends JsonValue
case class JsonNumber(value: Double) extends JsonValue
case class JsonBool(value: Boolean) extends JsonValue
case class JsonNull() extends JsonValue
case class JsonArray(values: List[JsonValue]) extends JsonValue
case class JsonObject(fields: Map[String, JsonValue]) extends JsonValue

def prettyPrint(json: JsonValue, indent: Int = 0): String = {
    val pad = "  " * indent
    json match {
        case JsonString(s) => s""""$s""""
        case JsonNumber(n) => n.toString
        case JsonBool(b) => b.toString
        case JsonNull() => "null"
        case JsonArray(values) =>
            val items = values.map(v => prettyPrint(v, indent + 1))
            s"[\n${items.map(i => pad + "  " + i).mkString(",\n")}\n$pad]"
        case JsonObject(fields) =>
            val items = fields.map { case (k, v) =>
                s""""$k": ${prettyPrint(v, indent + 1)}"""
            }
            s"{\n${items.map(i => pad + "  " + i).mkString(",\n")}\n$pad}"
    }
}

val json = JsonObject(Map(
    "name" -> JsonString("Alice"),
    "age" -> JsonNumber(30),
    "scores" -> JsonArray(List(JsonNumber(95), JsonNumber(87)))
))
println(prettyPrint(json))