let person = Person(name: "김철수", age: 28)
let mirror = Mirror(reflecting: person)

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)

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

// 출력:
// name: 김철수
// age: 28
// email: chulsoo@example.com

func describe(_ object: Any) -> String {
    let mirror = Mirror(reflecting: object)
    var description = "\(mirror.subjectType) {\n"
    
    for child in mirror.children {
        if let label = child.label {
            description += "  \(label): \(child.value)\n"
        }
    }
    
    description += "}"
    return description
}

// 사용 예시
struct Book {
    let title: String
    let author: String
    let pages: Int
    let isAvailable: Bool
}

let book = Book(
    title: "스위프트 마스터하기",
    author: "박개발",
    pages: 450,
    isAvailable: true
)

print(describe(book))

// 출력:
// Book {
//   title: 스위프트 마스터하기
//   author: 박개발
//   pages: 450
//   isAvailable: true
// }

func toDictionary(_ object: Any) -> [String: Any] {
    let mirror = Mirror(reflecting: object)
    var dictionary: [String: Any] = [:]
    
    for child in mirror.children {
        if let label = child.label {
            dictionary[label] = child.value
        }
    }
    
    return dictionary
}

// 사용 예시
struct Product {
    let id: Int
    let name: String
    let price: Double
    let inStock: Bool
}

let product = Product(id: 101, name: "맥북 프로", price: 2500000, inStock: true)
let dict = toDictionary(product)

print(dict)
// ["id": 101, "name": "맥북 프로", "price": 2500000.0, "inStock": true]

func findProperties<T>(of type: T.Type, in object: Any) -> [String: T] {
    let mirror = Mirror(reflecting: object)
    var result: [String: T] = [:]
    
    for child in mirror.children {
        if let label = child.label,
           let value = child.value as? T {
            result[label] = value
        }
    }
    
    return result
}

// 사용 예시
struct UserProfile {
    let username: String
    let age: Int
    let email: String
    let score: Int
    let bio: String
}

let profile = UserProfile(
    username: "swiftmaster",
    age: 25,
    email: "master@swift.com",
    score: 9500,
    bio: "Swift 개발자입니다"
)

// String 타입 프로퍼티만 찾기
let stringProps = findProperties(of: String.self, in: profile)
print(stringProps)
// ["username": "swiftmaster", "email": "master@swift.com", "bio": "Swift 개발자입니다"]

// Int 타입 프로퍼티만 찾기
let intProps = findProperties(of: Int.self, in: profile)
print(intProps)
// ["age": 25, "score": 9500]

func getTypeDescription(_ object: Any) -> String {
    let mirror = Mirror(reflecting: object)
    
    guard let displayStyle = mirror.displayStyle else {
        return "알 수 없는 타입"
    }
    
    switch displayStyle {
    case .struct:
        return "구조체 (Struct)"
    case .class:
        return "클래스 (Class)"
    case .enum:
        return "열거형 (Enum)"
    case .tuple:
        return "튜플 (Tuple)"
    case .optional:
        return "옵셔널 (Optional)"
    case .collection:
        return "컬렉션 (Collection)"
    case .dictionary:
        return "딕셔너리 (Dictionary)"
    case .set:
        return "집합 (Set)"
    @unknown default:
        return "기타 타입"
    }
}

// 테스트
struct MyStruct { let value: Int }
class MyClass { let value: Int; init(value: Int) { self.value = value } }
enum MyEnum { case first, second }

print(getTypeDescription(MyStruct(value: 10)))  // 구조체 (Struct)
print(getTypeDescription(MyClass(value: 20)))   // 클래스 (Class)
print(getTypeDescription(MyEnum.first))         // 열거형 (Enum)
print(getTypeDescription([1, 2, 3]))            // 컬렉션 (Collection)
print(getTypeDescription(["key": "value"]))     // 딕셔너리 (Dictionary)

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

class Dog: Animal {
    let breed: String
    init(breed: String) {
        self.breed = breed
        super.init(species: "개")
    }
}

class Poodle: Dog {
    let color: String
    init(color: String) {
        self.color = color
        super.init(breed: "푸들")
    }
}

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

let myPoodle = Poodle(color: "흰색")
printInheritanceChain(myPoodle)

// 출력:
// 📦 Poodle
//   ├─ color: 흰색
//   📦 Dog
//     ├─ breed: 푸들
//     📦 Animal
//       ├─ species: 개

struct SecureData {
    let publicInfo: String
    private let secretKey: String
    
    init(publicInfo: String, secretKey: String) {
        self.publicInfo = publicInfo
        self.secretKey = secretKey
    }
}

let data = SecureData(publicInfo: "공개 정보", secretKey: "비밀키123")
let mirror = Mirror(reflecting: data)

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

// 출력:
// publicInfo: 공개 정보
// secretKey: 비밀키123

// ⚠️ 주의: private이어도 Mirror로는 볼 수 있어요!
// 하지만 직접 접근은 불가능합니다: data.secretKey // 컴파일 에러

struct BankAccount: CustomReflectable {
    let accountNumber: String
    private let balance: Double
    private let pin: String
    
    init(accountNumber: String, balance: Double, pin: String) {
        self.accountNumber = accountNumber
        self.balance = balance
        self.pin = pin
    }
    
    // 커스텀 Mirror 정의
    var customMirror: Mirror {
        return Mirror(
            self,
            children: [
                "accountNumber": accountNumber,
                "balance": "***숨김***",  // 민감한 정보는 숨김
                "pin": "****"              // PIN은 절대 노출 안 함
            ],
            displayStyle: .struct
        )
    }
}

let account = BankAccount(
    accountNumber: "123-456-789",
    balance: 1000000,
    pin: "1234"
)

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

// 출력:
// accountNumber: 123-456-789
// balance: ***숨김***
// pin: ****

func deepInspect(_ object: Any, indent: String = "") {
    let mirror = Mirror(reflecting: object)
    
    print("\(indent)📦 타입: \(mirror.subjectType)")
    
    for child in mirror.children {
        let label = child.label ?? "unnamed"
        let value = child.value
        
        print("\(indent)├─ \(label):", terminator: " ")
        
        // 기본 타입이면 바로 출력
        if let stringValue = value as? String {
            print("\"\(stringValue)\"")
        } else if let intValue = value as? Int {
            print(intValue)
        } else if let doubleValue = value as? Double {
            print(doubleValue)
        } else if let boolValue = value as? Bool {
            print(boolValue)
        } else {
            // 복잡한 타입이면 재귀 호출
            print("")
            deepInspect(value, indent: indent + "  ")
        }
    }
}

// 테스트용 중첩 구조
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
}

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

deepInspect(employee)

// 출력:
// 📦 타입: Employee
// ├─ name: "이개발"
// ├─ age: 30
// ├─ company: 
//   📦 타입: Company
//   ├─ name: "테크스타트업"
//   ├─ address: 
//     📦 타입: Address
//     ├─ street: "테헤란로 123"
//     ├─ city: "서울"
//     ├─ zipCode: "06234"

func findDifferences(between obj1: Any, and obj2: Any) -> [String: (Any, Any)] {
    let mirror1 = Mirror(reflecting: obj1)
    let mirror2 = Mirror(reflecting: obj2)
    
    var differences: [String: (Any, Any)] = [:]
    
    // obj1의 프로퍼티를 딕셔너리로 변환
    var props1: [String: Any] = [:]
    for child in mirror1.children {
        if let label = child.label {
            props1[label] = child.value
        }
    }
    
    // obj2의 프로퍼티를 딕셔너리로 변환
    var props2: [String: Any] = [:]
    for child in mirror2.children {
        if let label = child.label {
            props2[label] = child.value
        }
    }
    
    // 차이점 찾기
    for (key, value1) in props1 {
        if let value2 = props2[key] {
            // 간단한 비교 (실제로는 더 정교한 비교 필요)
            if "\(value1)" != "\(value2)" {
                differences[key] = (value1, value2)
            }
        }
    }
    
    return differences
}

// 사용 예시
struct Config {
    let serverURL: String
    let timeout: Int
    let enableLogging: Bool
}

let oldConfig = Config(
    serverURL: "https://api.old.com",
    timeout: 30,
    enableLogging: false
)

let newConfig = Config(
    serverURL: "https://api.new.com",
    timeout: 60,
    enableLogging: true
)

let diffs = findDifferences(between: oldConfig, and: newConfig)

print("🔍 변경된 설정:")
for (key, values) in diffs {
    print("  \(key): \(values.0) → \(values.1)")
}

// 출력:
// 🔍 변경된 설정:
//   serverURL: https://api.old.com → https://api.new.com
//   timeout: 30 → 60
//   enableLogging: false → true

import XCTest

// 테스트 헬퍼 함수
func assertHasProperty<T>(
    _ object: Any,
    named propertyName: String,
    ofType type: T.Type,
    withValue expectedValue: T,
    file: StaticString = #file,
    line: UInt = #line
) where T: Equatable {
    let mirror = Mirror(reflecting: object)
    
    for child in mirror.children {
        if let label = child.label, label == propertyName {
            if let actualValue = child.value as? T {
                XCTAssertEqual(
                    actualValue,
                    expectedValue,
                    "프로퍼티 '\(propertyName)'의 값이 예상과 다릅니다",
                    file: file,
                    line: line
                )
                return
            } else {
                XCTFail(
                    "프로퍼티 '\(propertyName)'의 타입이 \(T.self)가 아닙니다",
                    file: file,
                    line: line
                )
                return
            }
        }
    }
    
    XCTFail(
        "프로퍼티 '\(propertyName)'을 찾을 수 없습니다",
        file: file,
        line: line
    )
}

// 테스트 예시
class UserTests: XCTestCase {
    func testUserCreation() {
        struct User {
            let id: Int
            let username: String
            let isActive: Bool
        }
        
        let user = User(id: 1, username: "testuser", isActive: true)
        
        // Mirror를 활용한 검증
        assertHasProperty(user, named: "id", ofType: Int.self, withValue: 1)
        assertHasProperty(user, named: "username", ofType: String.self, withValue: "testuser")
        assertHasProperty(user, named: "isActive", ofType: Bool.self, withValue: true)
    }
}

class AutoLogger {
    static func log(_ object: Any, event: String) {
        let mirror = Mirror(reflecting: object)
        let typeName = "\(mirror.subjectType)"
        
        var logMessage = """
        ═══════════════════════════════════════
        📊 이벤트: \(event)
        🏷️  타입: \(typeName)
        ⏰ 시간: \(Date())
        ───────────────────────────────────────
        """
        
        for child in mirror.children {
            if let label = child.label {
                logMessage += "\n  • \(label): \(child.value)"
            }
        }
        
        logMessage += "\n═══════════════════════════════════════"
        
        print(logMessage)
    }
}

// 사용 예시
struct OrderPlaced {
    let orderId: String
    let userId: String
    let totalAmount: Double
    let items: [String]
    let timestamp: Date
}

let order = OrderPlaced(
    orderId: "ORD-2024-001",
    userId: "USER-123",
    totalAmount: 89000,
    items: ["맥북 케이스", "무선 마우스"],
    timestamp: Date()
)

AutoLogger.log(order, event: "주문 완료")

// 출력:
// ═══════════════════════════════════════
// 📊 이벤트: 주문 완료
// 🏷️  타입: OrderPlaced
// ⏰ 시간: 2024-01-15 14:30:00 +0000
// ───────────────────────────────────────
//   • orderId: ORD-2024-001
//   • userId: USER-123
//   • totalAmount: 89000.0
//   • items: ["맥북 케이스", "무선 마우스"]
//   • timestamp: 2024-01-15 14:30:00 +0000
// ═══════════════════════════════════════

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

let person = Person(name: "김철수", age: 28)

// 1. Mirror - 프로퍼티 순회
let mirror = Mirror(reflecting: person)
print("Mirror로 확인:")
for child in mirror.children {
    if let label = child.label {
        print("  \(label): \(child.value)")
    }
}

// 2. type(of:) - 타입만 확인
let personType = type(of: person)
print("\ntype(of:)로 확인: \(personType)")  // Person

// 3. is - 타입 체크
let isPersonType = person is Person
print("\nis로 확인: \(isPersonType)")  // true

// 4. as? - 타입 캐스팅
let anyValue: Any = person
if let castedPerson = anyValue as? Person {
    print("\nas?로 확인: \(castedPerson.name)")  // 김철수
}

// 성능 비교 (대략적인 속도)
// type(of:) > is/as? > Mirror
// Mirror는 가장 느리지만 가장 많은 정보를 제공

// ❌ 나쁜 예: 반복문 안에서 Mirror 생성
func processItems(_ items: [Person]) {
    for item in items {
        let mirror = Mirror(reflecting: item)  // 매번 생성!
        // ... 처리 ...
    }
}

// ✅ 좋은 예: 타입별로 한 번만 생성
class MirrorCache {
    private var cache: [String: Mirror] = [:]
    
    func getMirror(for object: Any) -> Mirror {
        let typeName = "\(type(of: object))"
        
        if let cached = cache[typeName] {
            return cached
        }
        
        let mirror = Mirror(reflecting: object)
        cache[typeName] = mirror
        return mirror
    }
}

let cache = MirrorCache()

func processItemsOptimized(_ items: [Person]) {
    for item in items {
        let mirror = cache.getMirror(for: item)
        // ... 처리 ...
    }
}