let mirror = Mirror(reflecting: someObject)

// 주요 프로퍼티들
mirror.children        // 객체의 프로퍼티들
mirror.displayStyle    // 표시 스타일 (struct, class, enum 등)
mirror.subjectType     // 대상의 타입
mirror.superclassMirror // 부모 클래스의 Mirror (있다면)

struct Person {
    let name: String
    let age: Int
    let email: String
}

let person = Person(name: "김철수", age: 28, email: "chulsoo@example.com")
let mirror = Mirror(reflecting: person)

print("타입: \(mirror.subjectType)")
print("프로퍼티 개수: \(mirror.children.count)")

for child in mirror.children {
    if let propertyName = child.label {
        print("\(propertyName): \(child.value)")
    }
}

타입: Person
프로퍼티 개수: 3
name: 김철수
age: 28
email: chulsoo@example.com

struct Product {
    let id: Int
    let name: String
    let price: Double
    let inStock: Bool
    let tags: [String]
}

let product = Product(
    id: 101,
    name: "무선 이어폰",
    price: 89000,
    inStock: true,
    tags: ["전자제품", "오디오", "블루투스"]
)

let mirror = Mirror(reflecting: product)

// 각 프로퍼티의 타입까지 확인하기
for child in mirror.children {
    let propertyName = child.label ?? "unknown"
    let propertyValue = child.value
    let propertyType = type(of: propertyValue)
    
    print("\(propertyName): \(propertyValue) (타입: \(propertyType))")
}

id: 101 (타입: Int)
name: 무선 이어폰 (타입: String)
price: 89000.0 (타입: Double)
inStock: true (타입: Bool)
tags: ["전자제품", "오디오", "블루투스"] (타입: Array<String>)

// DisplayStyle 열거형의 케이스들
.struct      // 구조체
.class       // 클래스
.enum        // 열거형
.tuple       // 튜플
.optional    // 옵셔널
.collection  // 컬렉션 (Array, Set 등)
.dictionary  // 딕셔너리
.set         // Set

func analyzeType(_ value: Any) {
    let mirror = Mirror(reflecting: value)
    
    print("=== 타입 분석 ===")
    print("타입: \(mirror.subjectType)")
    
    if let style = mirror.displayStyle {
        switch style {
        case .struct:
            print("이것은 구조체입니다! 🏗️")
        case .class:
            print("이것은 클래스입니다! 🎓")
        case .enum:
            print("이것은 열거형입니다! 📋")
        case .tuple:
            print("이것은 튜플입니다! 📦")
        case .optional:
            print("이것은 옵셔널입니다! ❓")
        case .collection:
            print("이것은 컬렉션입니다! 📚")
        case .dictionary:
            print("이것은 딕셔너리입니다! 📖")
        case .set:
            print("이것은 Set입니다! 🎯")
        @unknown default:
            print("알 수 없는 타입입니다!")
        }
    }
    
    print("프로퍼티 개수: \(mirror.children.count)\n")
}

// 테스트
struct Book { let title: String; let pages: Int }
class Author { let name: String; init(name: String) { self.name = name } }

analyzeType(Book(title: "Swift 마스터", pages: 500))
analyzeType(Author(name: "김개발"))
analyzeType([1, 2, 3, 4, 5])
analyzeType(["name": "홍길동", "age": "30"])

struct Address {
    let street: String
    let city: String
    let zipCode: String
}

struct Company {
    let name: String
    let address: Address
}

struct Employee {
    let name: String
    let age: Int
    let company: Company
}

func printObjectStructure(_ object: Any, indent: String = "") {
    let mirror = Mirror(reflecting: object)
    
    for child in mirror.children {
        let label = child.label ?? "unnamed"
        let value = child.value
        
        print("\(indent)├─ \(label): ", terminator: "")
        
        let childMirror = Mirror(reflecting: value)
        
        // 자식이 있으면 재귀적으로 탐색
        if childMirror.children.count > 0 {
            print("\(type(of: value))")
            printObjectStructure(value, indent: indent + "│  ")
        } else {
            print("\(value)")
        }
    }
}

let employee = Employee(
    name: "이영희",
    age: 32,
    company: Company(
        name: "테크스타트업",
        address: Address(
            street: "테헤란로 123",
            city: "서울",
            zipCode: "06234"
        )
    )
)

print("🌳 객체 구조 트리:")
printObjectStructure(employee)

🌳 객체 구조 트리:
├─ name: 이영희
├─ age: 32
├─ company: Company
│  ├─ name: 테크스타트업
│  ├─ address: Address
│  │  ├─ street: 테헤란로 123
│  │  ├─ city: 서울
│  │  ├─ zipCode: 06234

protocol Describable {
    var description: String { get }
}

struct User: Describable {
    let id: Int
    let username: String
    let email: String
    
    var description: String {
        return "User #\(id): \(username)"
    }
}

struct Post: Describable {
    let title: String
    let content: String
    let author: String
    
    var description: String {
        return "'\(title)' by \(author)"
    }
}

func analyzeDescribable(_ items: [Any]) {
    for item in items {
        let mirror = Mirror(reflecting: item)
        
        print("\n📦 타입: \(mirror.subjectType)")
        
        // Describable 프로토콜을 채택했는지 확인
        if let describable = item as? Describable {
            print("✅ Describable 프로토콜 채택")
            print("📝 설명: \(describable.description)")
        } else {
            print("❌ Describable 프로토콜 미채택")
        }
        
        // 모든 프로퍼티 출력
        print("🔍 프로퍼티:")
        for child in mirror.children {
            if let label = child.label {
                print("   • \(label): \(child.value)")
            }
        }
    }
}

let user = User(id: 1, username: "swiftmaster", email: "swift@example.com")
let post = Post(title: "Mirror 완전정복", content: "...", author: "김개발")
let number = 42

analyzeDescribable([user, post, number])

func toJSON(_ object: Any) -> String {
    let mirror = Mirror(reflecting: object)
    
    guard mirror.children.count > 0 else {
        // 기본 타입 처리
        if let string = object as? String {
            return "\"\(string)\""
        } else if let number = object as? CustomStringConvertible {
            return "\(number)"
        }
        return "\"\(object)\""
    }
    
    var json = "{"
    var isFirst = true
    
    for child in mirror.children {
        guard let label = child.label else { continue }
        
        if !isFirst {
            json += ","
        }
        isFirst = false
        
        json += "\"\(label)\":"
        
        let value = child.value
        let valueMirror = Mirror(reflecting: value)
        
        // 중첩 객체 처리
        if valueMirror.children.count > 0 {
            json += toJSON(value)
        } else if let string = value as? String {
            json += "\"\(string)\""
        } else if let array = value as? [Any] {
            json += "["
            json += array.map { toJSON($0) }.joined(separator: ",")
            json += "]"
        } else {
            json += "\(value)"
        }
    }
    
    json += "}"
    return json
}

// 테스트
struct BlogPost {
    let id: Int
    let title: String
    let author: String
    let tags: [String]
    let published: Bool
}

let post = BlogPost(
    id: 42,
    title: "Swift Mirror 마스터하기",
    author: "김개발",
    tags: ["Swift", "iOS", "Programming"],
    published: true
)

let jsonString = toJSON(post)
print("📄 생성된 JSON:")
print(jsonString)

📄 생성된 JSON:
{"id":42,"title":"Swift Mirror 마스터하기","author":"김개발","tags":["Swift","iOS","Programming"],"published":true}

func safelyExtractValue<T>(from object: Any, key: String, as type: T.Type) -> T? {
    let mirror = Mirror(reflecting: object)
    
    for child in mirror.children {
        if child.label == key {
            return child.value as? T
        }
    }
    
    return nil
}

// 사용 예제
struct Config {
    let apiKey: String
    let timeout: Int
    let enableLogging: Bool
}

let config = Config(
    apiKey: "abc123xyz",
    timeout: 30,
    enableLogging: true
)

// 안전한 값 추출
if let apiKey = safelyExtractValue(from: config, key: "apiKey", as: String.self) {
    print("✅ API Key: \(apiKey)")
}

if let timeout = safelyExtractValue(from: config, key: "timeout", as: Int.self) {
    print("✅ Timeout: \(timeout)초")
}

// 잘못된 타입으로 시도하면 nil 반환
if let wrongType = safelyExtractValue(from: config, key: "timeout", as: String.self) {
    print("이 코드는 실행되지 않음")
} else {
    print("❌ 타입 불일치: timeout은 String이 아닙니다")
}

func areEqual(_ lhs: Any, _ rhs: Any) -> Bool {
    let lhsMirror = Mirror(reflecting: lhs)
    let rhsMirror = Mirror(reflecting: rhs)
    
    // 타입이 다르면 false
    if lhsMirror.subjectType != rhsMirror.subjectType {
        return false
    }
    
    // 프로퍼티 개수가 다르면 false
    if lhsMirror.children.count != rhsMirror.children.count {
        return false
    }
    
    // 각 프로퍼티 비교
    let lhsChildren = Array(lhsMirror.children)
    let rhsChildren = Array(rhsMirror.children)
    
    for (index, lhsChild) in lhsChildren.enumerated() {
        let rhsChild = rhsChildren[index]
        
        // 레이블 비교
        if lhsChild.label != rhsChild.label {
            return false
        }
        
        // 값 비교 (재귀적으로)
        let lhsValue = lhsChild.value
        let rhsValue = rhsChild.value
        
        // 기본 타입들은 직접 비교
        if let lhsString = lhsValue as? String,
           let rhsString = rhsValue as? String {
            if lhsString != rhsString { return false }
        } else if let lhsInt = lhsValue as? Int,
                  let rhsInt = rhsValue as? Int {
            if lhsInt != rhsInt { return false }
        } else if let lhsBool = lhsValue as? Bool,
                  let rhsBool = rhsValue as? Bool {
            if lhsBool != rhsBool { return false }
        } else {
            // 복잡한 타입은 재귀적으로 비교
            if !areEqual(lhsValue, rhsValue) {
                return false
            }
        }
    }
    
    return true
}

// 테스트
struct Point {
    let x: Int
    let y: Int
}

let point1 = Point(x: 10, y: 20)
let point2 = Point(x: 10, y: 20)
let point3 = Point(x: 15, y: 25)

print("point1 == point2: \(areEqual(point1, point2))") // true
print("point1 == point3: \(areEqual(point1, point3))") // false

class Animal {
    let species: String
    let age: Int
    
    init(species: String, age: Int) {
        self.species = species
        self.age = age
    }
}

class Dog: Animal {
    let name: String
    let breed: String
    
    init(name: String, breed: String, age: Int) {
        self.name = name
        self.breed = breed
        super.init(species: "Canis familiaris", age: age)
    }
}

class Puppy: Dog {
    let isVaccinated: Bool
    
    init(name: String, breed: String, age: Int, isVaccinated: Bool) {
        self.isVaccinated = isVaccinated
        super.init(name: name, breed: breed, age: age)
    }
}

func printInheritanceChain(_ object: Any) {
    var currentMirror: Mirror? = Mirror(reflecting: object)
    var level = 0
    
    while let mirror = currentMirror {
        let indent = String(repeating: "  ", count: level)
        print("\(indent)📦 \(mirror.subjectType)")
        
        for child in mirror.children {
            if let label = child.label {
                print("\(indent)  ├─ \(label): \(child.value)")
            }
        }
        
        currentMirror = mirror.superclassMirror
        level += 1
        
        if currentMirror != nil {
            print("\(indent)  ⬆️  상속")
        }
    }
}

let puppy = Puppy(
    name: "초코",
    breed: "골든 리트리버",
    age: 1,
    isVaccinated: true
)

print("🐕 상속 구조 분석:")
printInheritanceChain(puppy)

🐕 상속 구조 분석:
📦 Puppy
  ├─ isVaccinated: true
  ⬆️  상속
  📦 Dog
    ├─ name: 초코
    ├─ breed: 골든 리트리버
    ⬆️  상속
    📦 Animal
      ├─ species: Canis familiaris
      ├─ age: 1

enum NetworkResponse {
    case success(data: Data, statusCode: Int)
    case failure(error: Error, statusCode: Int)
    case loading
    case idle
}

struct MockError: Error {
    let message: String
}

func analyzeResponse(_ response: NetworkResponse) {
    let mirror = Mirror(reflecting: response)
    
    print("🔍 응답 분석")
    print("타입: \(mirror.subjectType)")
    print("DisplayStyle: \(mirror.displayStyle ?? .enum)")
    
    // 열거형 케이스 이름 추출
    if let firstChild = mirror.children.first {
        print("케이스: \(firstChild.label ?? "unknown")")
        
        // Associated values 추출
        let associatedMirror = Mirror(reflecting: firstChild.value)
        if associatedMirror.children.count > 0 {
            print("Associated Values:")
            for (index, child) in associatedMirror.children.enumerated() {
                let label = child.label ?? "value\(index)"
                print("  • \(label): \(child.value)")
            }
        } else {
            print("Associated Values 없음")
        }
    }
    print()
}

// 테스트
let successResponse = NetworkResponse.success(
    data: Data(),
    statusCode: 200
)

let failureResponse = NetworkResponse.failure(
    error: MockError(message: "네트워크 오류"),
    statusCode: 500
)

let loadingResponse = NetworkResponse.loading

analyzeResponse(successResponse)
analyzeResponse(failureResponse)
analyzeResponse(loadingResponse)

🔍 응답 분석
타입: NetworkResponse
DisplayStyle: enum
케이스: success
Associated Values:
  • data: 0 bytes
  • statusCode: 200

🔍 응답 분석
타입: NetworkResponse
DisplayStyle: enum
케이스: failure
Associated Values:
  • error: MockError(message: "네트워크 오류")
  • statusCode: 500

🔍 응답 분석
타입: NetworkResponse
DisplayStyle: enum
케이스: loading
Associated Values 없음

import Foundation

struct TestData {
    let id: Int
    let name: String
    let value: Double
}

// Mirror 사용
func extractWithMirror(_ data: TestData) -> String {
    let mirror = Mirror(reflecting: data)
    var result = ""
    for child in mirror.children {
        if let label = child.label {
            result += "\(label): \(child.value), "
        }
    }
    return result
}

// 직접 접근
func extractDirect(_ data: TestData) -> String {
    return "id: \(data.id), name: \(data.name), value: \(data.value)"
}

let testData = TestData(id: 1, name: "테스트", value: 3.14)

// 성능 측정
let iterations = 100_000

let mirrorStart = Date()
for _ in 0..<iterations {
    _ = extractWithMirror(testData)
}
let mirrorTime = Date().timeIntervalSince(mirrorStart)

let directStart = Date()
for _ in 0..<iterations {
    _ = extractDirect(testData)
}
let directTime = Date().timeIntervalSince(directStart)

print("📊 성능 비교 (\(iterations)회 반복)")
print("Mirror 사용: \(String(format: "%.4f", mirrorTime))초")
print("직접 접근: \(String(format: "%.4f", directTime))초")
print("차이: \(String(format: "%.1f", mirrorTime / directTime))배")

class ObjectDumper {
    
    enum DumpStyle {
        case compact
        case detailed
        case json
    }
    
    static func dump(_ object: Any, style: DumpStyle = .detailed) -> String {
        switch style {
        case .compact:
            return dumpCompact(object)
        case .detailed:
            return dumpDetailed(object)
        case .json:
            return dumpJSON(object)
        }
    }
    
    // 간단한 형식
    private static func dumpCompact(_ object: Any) -> String {
        let mirror = Mirror(reflecting: object)
        var result = "\(mirror.subjectType)("
        
        let properties = mirror.children.compactMap { child -> String? in
            guard let label = child.label else { return nil }
            return "\(label): \(child.value)"
        }
        
        result += properties.joined(separator: ", ")
        result += ")"
        return result
    }
    
    // 상세한 형식
    private static func dumpDetailed(_ object: Any, indent: Int = 0) -> String {
        let mirror = Mirror(reflecting: object)
        let indentStr = String(repeating: "  ", count: indent)
        var result = ""
        
        if indent == 0 {
            result += "╔══════════════════════════════════════╗\n"
            result += "║  Object Dump - Detailed View         ║\n"
            result += "╚══════════════════════════════════════╝\n\n"
        }
        
        result += "\(indentStr)📦 Type: \(mirror.subjectType)\n"
        
        if let displayStyle = mirror.displayStyle {
            result += "\(indentStr)🏷️  Style: \(displayStyle)\n"
        }
        
        if mirror.children.count > 0 {
            result += "\(indentStr)📋 Properties (\(mirror.children.count)):\n"
            
            for child in mirror.children {
                let label = child.label ?? "unnamed"
                let value = child.value
                let valueMirror = Mirror(reflecting: value)
                
                result += "\(indentStr)  • \(label): "
                
                if valueMirror.children.count > 0 {
                    result += "\n"
                    result += dumpDetailed(value, indent: indent + 2)
                } else {
                    result += "\(value) (\(type(of: value)))\n"
                }
            }
        }
        
        // 상속 정보
        if let superMirror = mirror.superclassMirror {
            result += "\(indentStr)⬆️  Inherits from:\n"
            result += dumpDetailed(superMirror, indent: indent + 1)
        }
        
        return result
    }
    
    // JSON 형식
    private static func dumpJSON(_ object: Any, indent: Int = 0) -> String {
        let mirror = Mirror(reflecting: object)
        let indentStr = String(repeating: "  ", count: indent)
        
        guard mirror.children.count > 0 else {
            if let string = object as? String {
                return "\"\(string)\""
            }
            return "\(object)"
        }
        
        var json = "{\n"
        let properties = Array(mirror.children)
        
        for (index, child) in properties.enumerated() {
            guard let label = child.label else { continue }
            
            json += "\(indentStr)  \"\(label)\": "
            
            let value = child.value
            let valueMirror = Mirror(reflecting: value)
            
            if valueMirror.children.count > 0 {
                json += dumpJSON(value, indent: indent + 1)
            } else if let string = value as? String {
                json += "\"\(string)\""
            } else if let array = value as? [Any] {
                json += "[\n"
                for (i, item) in array.enumerated() {
                    json += "\(indentStr)    \(dumpJSON(item, indent: indent + 2))"
                    if i < array.count - 1 { json += "," }
                    json += "\n"
                }
                json += "\(indentStr)  ]"
            } else {
                json += "\(value)"
            }
            
            if index < properties.count - 1 {
                json += ","
            }
            json += "\n"
        }
        
        json += "\(indentStr)}"
        return json
    }
}

// 테스트용 복잡한 구조
struct Project {
    let name: String
    let version: String
    let contributors: [String]
    let settings: Settings
}

struct Settings {
    let debugMode: Bool
    let maxConnections: Int
    let apiEndpoint: String
}

let project = Project(
    name: "SwiftMirrorDemo",
    version: "1.0.0",
    contributors: ["김개발", "이코딩", "박프로그래머"],
    settings: Settings(
        debugMode: true,
        maxConnections: 100,
        apiEndpoint: "https://api.example.com"
    )
)

print("=== COMPACT ===")
print(ObjectDumper.dump(project, style: .compact))
print("\n=== DETAILED ===")
print(ObjectDumper.dump(project, style: .detailed))
print("\n=== JSON ===")
print(ObjectDumper.dump(project, style: .json))

// 1. 값 수정이 필요할 때: KeyPath 사용
struct User {
    var name: String
    var age: Int
}

var user = User(name: "홍길동", age: 30)
let nameKeyPath = \User.name

// KeyPath로 값 읽기와 쓰기
print(user[keyPath: nameKeyPath])  // "홍길동"
user[keyPath: nameKeyPath] = "김철수"
print(user[keyPath: nameKeyPath])  // "김철수"

// 2. 직렬화가 필요할 때: Codable 사용
struct Product: Codable {
    let id: Int
    let name: String
    let price: Double
}

let product = Product(id: 1, name: "노트북", price: 1500000)
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted

if let jsonData = try? encoder.encode(product),
   let jsonString = String(data: jsonData, encoding: .utf8) {
    print(jsonString)
}

// 3. 타입별 동작이 필요할 때: 프로토콜 사용
protocol Printable {
    func prettyPrint() -> String
}

extension User: Printable {
    func prettyPrint() -> String {
        return "👤 \(name) (나이: \(age))"
    }
}

extension Product: Printable {
    func prettyPrint() -> String {
        return "🛍️ \(name) - ₩\(price)"
    }
}

// 4. 범용 처리가 필요할 때: 제네릭 사용
func process<T>(_ items: [T], transform: (T) -> String) {
    for item in items {
        print(transform(item))
    }
}

protocol Validatable {
    func validate() -> [String]  // 에러 메시지 배열
}

struct ValidationRule {
    let fieldName: String
    let validator: (Any) -> String?
}

class FormValidator {
    
    static func validate(_ object: Any, rules: [ValidationRule]) -> [String: String] {
        let mirror = Mirror(reflecting: object)
        var errors: [String: String] = [:]
        
        for rule in rules {
            // 해당 필드 찾기
            for child in mirror.children {
                if child.label == rule.fieldName {
                    if let error = rule.validator(child.value) {
                        errors[rule.fieldName] = error
                    }
                    break
                }
            }
        }
        
        return errors
    }
    
    // 일반적인 검증 규칙들
    static func required(_ value: Any) -> String? {
        if let string = value as? String, string.isEmpty {
            return "필수 입력 항목입니다"
        }
        return nil
    }
    
    static func minLength(_ min: Int) -> (Any) -> String? {
        return { value in
            if let string = value as? String, string.count < min {
                return "최소 \(min)자 이상 입력해주세요"
            }
            return nil
        }
    }
    
    static func email(_ value: Any) -> String? {
        guard let string = value as? String else { return nil }
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let predicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        if !predicate.evaluate(with: string) {
            return "올바른 이메일 형식이 아닙니다"
        }
        return nil
    }
}

// 재능넷 회원가입 폼
struct SignupForm {
    let username: String
    let email: String
    let password: String
    let bio: String
}

let form = SignupForm(
    username: "개발자",
    email: "invalid-email",
    password: "123",
    bio: "안녕하세요"
)

let rules = [
    ValidationRule(fieldName: "username", validator: FormValidator.required),
    ValidationRule(fieldName: "username", validator: FormValidator.minLength(2)),
    ValidationRule(fieldName: "email", validator: FormValidator.email),
    ValidationRule(fieldName: "password", validator: FormValidator.minLength(8))
]

let errors = FormValidator.validate(form, rules: rules)

if errors.isEmpty {
    print("✅ 검증 통과!")
} else {
    print("❌ 검증 실패:")
    for (field, error) in errors {
        print("  • \(field): \(error)")
    }
}

❌ 검증 실패:
  • email: 올바른 이메일 형식이 아닙니다
  • password: 최소 8자 이상 입력해주세요

enum LogLevel: String {
    case debug = "🔍"
    case info = "ℹ️"
    case warning = "⚠️"
    case error = "❌"
}

class AutoLogger {
    
    static func log(_ object: Any, level: LogLevel = .info, context: String = "") {
        let timestamp = DateFormatter.localizedString(
            from: Date(),
            dateStyle: .none,
            timeStyle: .medium
        )
        
        print("\(level.rawValue) [\(timestamp)] \(context)")
        print(generateLogMessage(object, indent: 1))
        print(String(repeating: "─", count: 50))
    }
    
    private static func generateLogMessage(_ object: Any, indent: Int) -> String {
        let mirror = Mirror(reflecting: object)
        let indentStr = String(repeating: "  ", count: indent)
        var message = ""
        
        if mirror.children.count == 0 {
            return "\(indentStr)\(object)"
        }
        
        message += "\(indentStr)Type: \(mirror.subjectType)\n"
        
        for child in mirror.children {
            let label = child.label ?? "value"
            let value = child.value
            let valueMirror = Mirror(reflecting: value)
            
            if valueMirror.children.count > 0 {
                message += "\(indentStr)\(label):\n"
                message += generateLogMessage(value, indent: indent + 1)
            } else {
                message += "\(indentStr)\(label): \(value)\n"
            }
        }
        
        return message
    }
}

// 재능넷 거래 정보
struct Transaction {
    let id: String
    let buyer: String
    let seller: String
    let amount: Int
    let status: String
    let timestamp: Date
}

let transaction = Transaction(
    id: "TXN-2024-001",
    buyer: "김구매자",
    seller: "이판매자",
    amount: 50000,
    status: "completed",
    timestamp: Date()
)

AutoLogger.log(transaction, level: .info, context: "거래 완료")

struct SecureUser: CustomReflectable {
    let id: Int
    let username: String
    let email: String
    private let password: String
    private let apiKey: String
    
    // 커스텀 Mirror 정의
    var customMirror: Mirror {
        return Mirror(
            self,
            children: [
                "id": id,
                "username": username,
                "email": email,
                "password": "********",  // 비밀번호 숨김
                "apiKey": "********"     // API 키 숨김
            ],
            displayStyle: .struct
        )
    }
    
    init(id: Int, username: String, email: String, password: String, apiKey: String) {
        self.id = id
        self.username = username
        self.email = email
        self.password = password
        self.apiKey = apiKey
    }
}

let secureUser = SecureUser(
    id: 1,
    username: "secure_user",
    email: "user@example.com",
    password: "super_secret_password",
    apiKey: "sk_live_abc123xyz789"
)

// Mirror로 확인하면 민감한 정보가 숨겨져 있음
let mirror = Mirror(reflecting: secureUser)
print("🔒 보안 사용자 정보:")
for child in mirror.children {
    if let label = child.label {
        print("  \(label): \(child.value)")
    }
}

🔒 보안 사용자 정보:
  id: 1
  username: secure_user
  email: user@example.com
  password: ********
  apiKey: ********

struct ComparisonResult {
    let isEqual: Bool
    let differences: [String]
    
    var description: String {
        if isEqual {
            return "✅ 객체가 동일합니다"
        } else {
            var result = "❌ 객체가 다릅니다\n차이점:\n"
            for diff in differences {
                result += "  • \(diff)\n"
            }
            return result
        }
    }
}

class ObjectComparator {
    
    static func compare(_ lhs: Any, _ rhs: Any, path: String = "root") -> ComparisonResult {
        var differences: [String] = []
        
        let lhsMirror = Mirror(reflecting: lhs)
        let rhsMirror = Mirror(reflecting: rhs)
        
        // 타입 비교
        if lhsMirror.subjectType != rhsMirror.subjectType {
            differences.append("\(path): 타입 불일치 (\(lhsMirror.subjectType) != \(rhsMirror.subjectType))")
            return ComparisonResult(isEqual: false, differences: differences)
        }
        
        // 자식이 없는 경우 (기본 타입)
        if lhsMirror.children.count == 0 {
            if !areValuesEqual(lhs, rhs) {
                differences.append("\(path): 값 불일치 (\(lhs) != \(rhs))")
            }
            return ComparisonResult(isEqual: differences.isEmpty, differences: differences)
        }
        
        // 프로퍼티 개수 비교
        if lhsMirror.children.count != rhsMirror.children.count {
            differences.append("\(path): 프로퍼티 개수 불일치")
            return ComparisonResult(isEqual: false, differences: differences)
        }
        
        // 각 프로퍼티 비교
        let lhsChildren = Array(lhsMirror.children)
        let rhsChildren = Array(rhsMirror.children)
        
        for (index, lhsChild) in lhsChildren.enumerated() {
            let rhsChild = rhsChildren[index]
            let label = lhsChild.label ?? "[\(index)]"
            let newPath = "\(path).\(label)"
            
            // 레이블 비교
            if lhsChild.label != rhsChild.label {
                differences.append("\(newPath): 프로퍼티 이름 불일치")
                continue
            }
            
            // 재귀적으로 값 비교
            let childResult = compare(lhsChild.value, rhsChild.value, path: newPath)
            differences.append(contentsOf: childResult.differences)
        }
        
        return ComparisonResult(isEqual: differences.isEmpty, differences: differences)
    }
    
    private static func areValuesEqual(_ lhs: Any, _ rhs: Any) -> Bool {
        // String 비교
        if let lhsString = lhs as? String, let rhsString = rhs as? String {
            return lhsString == rhsString
        }
        
        // Int 비교
        if let lhsInt = lhs as? Int, let rhsInt = rhs as? Int {
            return lhsInt == rhsInt
        }
        
        // Double 비교
        if let lhsDouble = lhs as? Double, let rhsDouble = rhs as? Double {
            return abs(lhsDouble - rhsDouble) < 0.0001
        }
        
        // Bool 비교
        if let lhsBool = lhs as? Bool, let rhsBool = rhs as? Bool {
            return lhsBool == rhsBool
        }
        
        // 배열 비교
        if let lhsArray = lhs as? [Any], let rhsArray = rhs as? [Any] {
            if lhsArray.count != rhsArray.count { return false }
            for (l, r) in zip(lhsArray, rhsArray) {
                if !areValuesEqual(l, r) { return false }
            }
            return true
        }
        
        // 기본적으로 문자열 표현 비교
        return "\(lhs)" == "\(rhs)"
    }
}

// 테스트
struct UserProfile {
    let name: String
    let age: Int
    let email: String
    let preferences: Preferences
}

struct Preferences {
    let theme: String
    let notifications: Bool
    let language: String
}

let profile1 = UserProfile(
    name: "김철수",
    age: 28,
    email: "chulsoo@example.com",
    preferences: Preferences(
        theme: "dark",
        notifications: true,
        language: "ko"
    )
)

let profile2 = UserProfile(
    name: "김철수",
    age: 29,  // 다름!
    email: "chulsoo@example.com",
    preferences: Preferences(
        theme: "light",  // 다름!
        notifications: true,
        language: "ko"
    )
)

let result = ObjectComparator.compare(profile1, profile2)
print(result.description)

❌ 객체가 다릅니다
차이점:
  • root.age: 값 불일치 (28 != 29)
  • root.preferences.theme: 값 불일치 (dark != light)