Day 6 · UIKit과 함께 살기

import UIKit
import SwiftUI

struct Order: Identifiable {
    let id: Int
    let title: String
}

struct OrderListView: View {
    let orders: [Order]
    var onSelect: (Order) -> Void                  // 전환은 요청만 한다

    var body: some View {
        List(orders) { order in
            Button(order.title) { onSelect(order) }
        }
    }
}

final class OrderDetailViewController: UIViewController {}   // 기존 UIKit 화면

@MainActor
final class OrdersCoordinator {
    private let navigationController: UINavigationController
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let list = OrderListView(orders: [Order(id: 1, title: "주문 #1")]) { [weak self] order in
            self?.showDetail(order)                    // push는 UIKit이 한다
        }
        let host = UIHostingController(rootView: list)
        host.title = "주문"
        navigationController.pushViewController(host, animated: true)
    }

    private func showDetail(_ order: Order) {
        let detail = OrderDetailViewController()
        detail.title = order.title
        navigationController.pushViewController(detail, animated: true)
    }
}

import UIKit
import SwiftUI

struct SummaryCard: View {
    var body: some View {
        VStack(alignment: .leading) {
            Text("이번 달 지출").font(.headline)
            Text("₩1,240,000").font(.title.bold())
        }
        .padding()
    }
}

final class DashboardViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        let host = UIHostingController(rootView: SummaryCard())
        // SwiftUI 내용 크기가 바뀌면 intrinsicContentSize도 따라 바뀐다 (iOS 16+)
        host.sizingOptions = .intrinsicContentSize

        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)                      // ③ 빠뜨리지 말 것
    }
}

import UIKit
import SwiftUI

@Observable final class HeartData {
    var beatsPerMinute = 78
}

struct HeartRateView: View {
    var data: HeartData                    // 래퍼 없음
    var body: some View { Text("\(data.beatsPerMinute) BPM") }
}

final class HeartRateViewController: UIViewController {
    let data: HeartData                    // UIKit 쪽은 참조만 보관

    init(data: HeartData) {
        self.data = data
        super.init(nibName: nil, bundle: nil)
    }
    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        let host = UIHostingController(rootView: HeartRateView(data: data))
        addChild(host)
        host.view.frame = view.bounds       // 여기는 UIKit이 부모 — frame 지정 OK
        host.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(host.view)
        host.didMove(toParent: self)
    }

    func receive(sample: Int) {
        data.beatsPerMinute = sample        // body가 읽은 값 → 자동 갱신
    }
}

import UIKit
import SwiftUI

@Observable final class HeartSample: Identifiable {
    let id = UUID()
    var bpm: Int
    init(bpm: Int) { self.bpm = bpm }
}

struct HeartRateRow: View {
    var sample: HeartSample
    var body: some View {
        HStack {
            Label("Heart Rate", systemImage: "heart.fill")
                .foregroundStyle(.pink)
                .font(.headline)
            Spacer()
            Text("\(sample.bpm) BPM").monospacedDigit()
        }
    }
}

final class HeartListViewController: UIViewController {
    private var samples = [HeartSample(bpm: 78), HeartSample(bpm: 94)]
    private var dataSource: UICollectionViewDiffableDataSource<Int, UUID>!

    override func viewDidLoad() {
        super.viewDidLoad()
        let layout = UICollectionViewCompositionalLayout.list(using: .init(appearance: .insetGrouped))
        let collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
        collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(collectionView)

        let registration = UICollectionView.CellRegistration<UICollectionViewListCell, UUID> {
            [unowned self] cell, _, id in
            guard let sample = samples.first(where: { $0.id == id }) else { return }
            cell.contentConfiguration = UIHostingConfiguration {
                HeartRateRow(sample: sample)
            }
            .margins(.horizontal, 20)             // 기본은 셀 layout margins
        }
        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) {
            collectionView, indexPath, id in
            collectionView.dequeueConfiguredReusableCell(using: registration, for: indexPath, item: id)
        }
        var snapshot = NSDiffableDataSourceSnapshot<Int, UUID>()
        snapshot.appendSections([0])
        snapshot.appendItems(samples.map(\.id))    // 모델이 아니라 식별자
        dataSource.apply(snapshot)
    }

    func receive(bpm: Int, for id: UUID) {
        samples.first(where: { $0.id == id })?.bpm = bpm   // 스냅샷 재적용 없이 셀 갱신
    }
}

import UIKit
import SwiftUI

struct MedicalCondition: Identifiable {
    let id: UUID
    var text: String
}

final class ConditionStore {
    var items: [MedicalCondition] = []
    func delete(id: UUID) { items.removeAll { $0.id == id } }
}

func configure(_ cell: UICollectionViewListCell,
               with condition: MedicalCondition,
               store: ConditionStore) {
    cell.configurationUpdateHandler = { cell, state in
        cell.contentConfiguration = UIHostingConfiguration {
            HStack {
                Text(condition.text)
                Spacer()
                if state.isSelected {                    // UIKit 셀 상태를 SwiftUI에서 사용
                    Image(systemName: "checkmark")
                }
            }
            .swipeActions {
                Button(role: .destructive) {
                    store.delete(id: condition.id)       // indexPath가 아니라 안정 ID
                } label: {
                    Label("삭제", systemImage: "trash")
                }
            }
        }
        .background {                                    // 셀 가장자리까지 채운다
            Color.pink.opacity(0.08)
        }
    }
}

import SwiftUI
import UIKit

struct AttributedLabel: UIViewRepresentable {
    var text: NSAttributedString

    func makeUIView(context: Context) -> UILabel {
        let label = UILabel()
        label.numberOfLines = 0                   // 변하지 않는 설정은 여기서
        return label
    }

    func updateUIView(_ label: UILabel, context: Context) {
        label.attributedText = text               // 상태 반영
        label.isEnabled = context.environment.isEnabled   // SwiftUI 환경 읽기
    }

    // 부모가 제안한 폭으로 높이를 계산한다 (iOS 16+)
    func sizeThatFits(_ proposal: ProposedViewSize,
                      uiView: UILabel, context: Context) -> CGSize? {
        guard let width = proposal.width, width.isFinite else { return nil }  // nil = 기본 알고리즘
        return uiView.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude))
    }
}

#Preview {
    AttributedLabel(text: NSAttributedString(string: String(repeating: "긴 약관 문장 ", count: 20)))
        .padding()
}

import SwiftUI
import UIKit

struct RichTextView: UIViewRepresentable {
    @Binding var text: String

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

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

    func updateUIView(_ tv: UITextView, context: Context) {
        context.coordinator.parent = self          // ① 최신 바인딩으로 교체
        if tv.text != text { tv.text = text }      // ② 다를 때만 대입 — 커서 튐 방지
    }

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

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

#Preview {
    RichTextView(text: .constant("메모"))           // Preview에선 Binding.constant (Day 3)
        .frame(height: 120)
}

import SwiftUI
import UIKit

struct KeyboardAwareTextView: UIViewRepresentable {
    func makeCoordinator() -> Coordinator { Coordinator() }
    func makeUIView(context: Context) -> UITextView {
        context.coordinator.startObserving()
        return UITextView()
    }
    func updateUIView(_ uiView: UITextView, context: Context) {}

    static func dismantleUIView(_ uiView: UITextView, coordinator: Coordinator) {
        coordinator.stopObserving()            // 사라질 때 확실히 호출된다
    }

    final class Coordinator {
        private var token: NSObjectProtocol?
        func startObserving() {
            token = NotificationCenter.default.addObserver(
                forName: UIResponder.keyboardWillShowNotification,
                object: nil, queue: .main) { _ in print("키보드") }
        }
        func stopObserving() {
            if let token { NotificationCenter.default.removeObserver(token) }
        }
    }
}

import SwiftUI
import UIKit

// 회사에 이미 있는 VC라고 가정
protocol ProfileEditorDelegate: AnyObject {
    func profileEditor(_ vc: ProfileEditorViewController, didSave name: String)
    func profileEditorDidCancel(_ vc: ProfileEditorViewController)
}
final class ProfileEditorViewController: UIViewController {
    weak var delegate: ProfileEditorDelegate?
    var initialName = ""
}

struct ProfileEditor: UIViewControllerRepresentable {
    var name: String
    var onFinish: (String?) -> Void                 // nil = 취소

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

    func makeUIViewController(context: Context) -> ProfileEditorViewController {
        let vc = ProfileEditorViewController()
        vc.delegate = context.coordinator
        return vc
    }

    func updateUIViewController(_ vc: ProfileEditorViewController, context: Context) {
        context.coordinator.parent = self
        vc.initialName = name
    }

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

        func profileEditor(_ vc: ProfileEditorViewController, didSave name: String) {
            parent.onFinish(name)
        }
        func profileEditorDidCancel(_ vc: ProfileEditorViewController) {
            parent.onFinish(nil)
        }
    }
}

struct ProfileScreen: View {
    @State private var name = "효성"
    @State private var isEditing = false

    var body: some View {
        Button("\(name) 편집") { isEditing = true }
            .sheet(isPresented: $isEditing) {
                ProfileEditor(name: name) { newName in
                    if let newName { name = newName }
                    isEditing = false                 // 닫기는 SwiftUI 상태로
                }
            }
    }
}

import SwiftUI
import UIKit

struct PageDots: UIViewRepresentable {
    var numberOfPages: Int
    @Binding var currentPage: Int

    func makeUIView(context: Context) -> UIPageControl {
        let control = UIPageControl()
        control.numberOfPages = numberOfPages
        control.currentPageIndicatorTintColor = .systemPink
        control.pageIndicatorTintColor = .systemGray4
        return control
    }

    func updateUIView(_ control: UIPageControl, context: Context) {
        control.currentPage = currentPage
    }
}

struct PagerDemo: View {
    @State private var page = 0
    var body: some View {
        VStack(spacing: 20) {
            Text("현재 \(page + 1) / 5").font(.title2)
            PageDots(numberOfPages: 5, currentPage: $page)
            Button("다음") { page = (page + 1) % 5 }
        }
    }
}

#Preview { PagerDemo() }