05 · UIKit과 함께 살기 + 성능

struct RichTextView: UIViewRepresentable {
    @Binding var text: String            // 진실은 SwiftUI 쪽에 있다

    func makeUIView(context: Context) -> UITextView {
        let tv = UITextView()
        tv.delegate = context.coordinator // 다리를 연결
        return tv
    }

    func updateUIView(_ tv: UITextView, context: Context) {
        context.coordinator.parent = self       // ① 코디네이터가 최신 값을 보게 갱신
        if tv.text != text { tv.text = text }   // ② 같은 값이면 건드리지 않는다(커서 튐 방지)
    }

    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }

    final class Coordinator: NSObject, UITextViewDelegate {
        var parent: RichTextView
        init(parent: RichTextView) { self.parent = parent }

        // UIKit 이벤트 → SwiftUI 상태
        func textViewDidChange(_ tv: UITextView) { parent.text = tv.text }
    }
}

struct LegacyChart: UIViewControllerRepresentable {
    var points: [Double]
    var onSelect: (Int) -> Void            // 콜백은 클로저로 받는다

    func makeUIViewController(context: Context) -> ChartViewController {
        let vc = ChartViewController()
        vc.delegate = context.coordinator   // 다리 연결
        return vc
    }

    func updateUIViewController(_ vc: ChartViewController, context: Context) {
        context.coordinator.parent = self   // 최신 값으로 갱신
        if vc.points != points {            // 달라졌을 때만
            vc.points = points
            vc.redraw()
        }
    }

    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }

    // 여기도 static 이다 (dismantleUIView 와 동일)
    static func dismantleUIViewController(_ vc: ChartViewController,
                                          coordinator: Coordinator) {
        vc.cancelPendingRedraw()
    }

    final class Coordinator: NSObject, ChartViewControllerDelegate {
        var parent: LegacyChart
        init(parent: LegacyChart) { self.parent = parent }

        func chart(_ vc: ChartViewController, didSelect index: Int) {
            parent.onSelect(index)          // UIKit 이벤트 → SwiftUI 클로저
        }
    }
}

// 쓰는 쪽에서는 평범한 SwiftUI 뷰다
struct DashboardView: View {
    @State private var selected: Int?

    var body: some View {
        VStack {
            LegacyChart(points: [1, 4, 2, 8]) { selected = $0 }
                .frame(height: 220)         // 크기는 SwiftUI가 정한다
            if let selected {
                Text("\(selected)번 선택됨")
            }
        }
    }
}

let vc = UIHostingController(rootView: SettingsView())
navigationController?.pushViewController(vc, animated: true)   // 평범한 VC처럼

final class DashboardViewController: UIViewController {
    private var summary: UIHostingController<SummaryCardView>?

    override func viewDidLoad() {
        super.viewDidLoad()

        let host = UIHostingController(rootView: SummaryCardView())
        summary = host

        addChild(host)                                   // ① 자식 VC로 등록
        host.view.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(host.view)
        NSLayoutConstraint.activate([                    // ② 배치는 UIKit이 한다
            host.view.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            host.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            host.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
        ])
        host.didMove(toParent: self)                     // ③ 빠뜨리면 생명주기가 안 간다
    }

    // 데이터가 바뀌면 rootView를 갈아 끼운다
    func update(with model: Summary) {
        summary?.rootView = SummaryCardView(model: model)
    }
}

var body: some View {
    Self._printChanges()      // 무엇이 이 갱신을 유발했는지 출력
    return VStack { /* ... */ }
}

var body: some View {
    let visible = items.filter { $0.isActive }.sorted { $0.date > $1.date }
    return List(visible) { item in
        Text("\(item.name) · \(formatter.string(from: item.date))")   // 매 갱신마다 포매팅
    }
}

@Observable final class ItemListModel {
    private(set) var visible: [ItemRow] = []     // 이미 필터·정렬·포매팅된 결과

    func reload() { /* 여기서 한 번만 계산 */ }
}

var body: some View {
    List(model.visible) { row in
        Text(row.displayTitle)                   // 조립된 문자열을 그대로
    }
}

// ❌ 요소마다 1개 또는 0개
ForEach(namedFonts) { namedFont in
    if namedFont.name.count != 2 { Text(namedFont.name) }
}

// ✅ 조건을 스택으로 감싸 개수를 고정
ForEach(namedFonts) { namedFont in
    VStack {
        if namedFont.name.count != 2 { Text(namedFont.name) }
    }
}

List {
    // ① 인라인 필터 — 매 갱신마다 필터가 돌고, 행 수를 미리 못 구한다
    ForEach(dogs.filter { $0.isAdopted }) { dog in
        // ② 조건부 셀 — 요소당 1개 또는 0개
        if dog.hasToy {
            // ③ AnyView — 개수를 알 수 없다
            AnyView(DogCell(dog: dog))
        }
    }
}

@Observable final class Kennel {
    private(set) var all: [Dog] = []
    private(set) var adopted: [Dog] = []      // 미리 걸러 둔 결과

    func reload(_ dogs: [Dog]) {
        all = dogs
        adopted = dogs.filter(\.isAdopted)    // 데이터가 바뀔 때 한 번만
    }
}

List {
    // 요소당 정확히 1개 — 행 수 = adopted.count × 1
    ForEach(kennel.adopted) { dog in
        DogCell(dog: dog)                     // 분기는 셀 내부로 내렸다
    }
}

struct DogCell: View {
    let dog: Dog
    var body: some View {
        HStack {
            Text(dog.name)
            if dog.hasToy {                   // 셀 안의 분기는 행 수에 영향 없다
                Image(systemName: "star.fill")
            }
        }
    }
}

// ① 특정 값의 변화에 애니메이션을 붙인다 (권장)
Circle()
    .scaleEffect(scale)
    .animation(.easeIn, value: scale)

// ② 상태를 바꾸는 쪽에서 감싼다
withAnimation(.easeIn) { scale += 0.1 }