UIKit for SwiftUI developers

final class OrderListViewController: UIViewController {
    enum Section { case main }

    private let orders: OrderStore                     // an @Observable model, shared with SwiftUI screens
    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource<Section, Order.ID>!
    var onOrderSelected: ((Order.ID) -> Void)?

    init(orders: OrderStore) {
        self.orders = orders
        super.init(nibName: nil, bundle: nil)
    }
    required init?(coder: NSCoder) { fatalError("init(coder:) is not supported") }

    override func viewDidLoad() {
        super.viewDidLoad()
        title = "Orders"

        let layout = UICollectionViewCompositionalLayout.list(using: .init(appearance: .insetGrouped))
        collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
        collectionView.translatesAutoresizingMaskIntoConstraints = false
        collectionView.delegate = self
        view.addSubview(collectionView)
        NSLayoutConstraint.activate([
            collectionView.topAnchor.constraint(equalTo: view.topAnchor),
            collectionView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            collectionView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            collectionView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
        ])

        let cell = UICollectionView.CellRegistration<UICollectionViewListCell, Order.ID> { [weak self] cell, _, id in
            guard let order = self?.orders.order(id) else { return }
            var content = cell.defaultContentConfiguration()
            content.text = order.title
            content.secondaryText = order.status.label
            cell.contentConfiguration = content
        }
        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) { cv, indexPath, id in
            cv.dequeueConfiguredReusableCell(using: cell, for: indexPath, item: id)
        }
        observeOrders()
    }

    // UIKit doesn't redraw on its own: observe the model and apply snapshots
    private func observeOrders() {
        withObservationTracking {
            applySnapshot(ids: orders.all.map(\.id), changed: orders.recentlyChanged)
        } onChange: { [weak self] in
            Task { @MainActor in self?.observeOrders() }
        }
    }

    private func applySnapshot(ids: [Order.ID], changed: Set<Order.ID>) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Order.ID>()
        snapshot.appendSections([.main])
        snapshot.appendItems(ids)
        snapshot.reconfigureItems(ids.filter(changed.contains))   // update content without recreating cells
        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

extension OrderListViewController: UICollectionViewDelegate {
    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        guard let id = dataSource.itemIdentifier(for: indexPath) else { return }
        onOrderSelected?(id)
    }
}

// UIKit in SwiftUI: a text view with a binding
struct NotesTextView: UIViewRepresentable {
    @Binding var text: String

    func makeUIView(context: Context) -> UITextView {
        let view = UITextView()
        view.font = .preferredFont(forTextStyle: .body)
        view.adjustsFontForContentSizeCategory = true
        view.delegate = context.coordinator
        return view
    }

    func updateUIView(_ view: UITextView, context: Context) {
        context.coordinator.parent = self                 // keep the binding current
        if view.text != text { view.text = text }         // only when it differs: keeps the cursor
    }

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

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

        func textViewDidChange(_ textView: UITextView) {
            parent.text = textView.text                   // UIKit → SwiftUI
        }
    }
}

// SwiftUI in UIKit: a SwiftUI screen embedded as a child view controller
final class OrderDetailContainer: UIViewController {
    private let order: Order
    init(order: Order) { self.order = order; super.init(nibName: nil, bundle: nil) }
    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        let hosting = UIHostingController(rootView: OrderDetailView(order: order))
        hosting.sizingOptions = .intrinsicContentSize
        addChild(hosting)
        hosting.view.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(hosting.view)
        NSLayoutConstraint.activate([
            hosting.view.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            hosting.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            hosting.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            hosting.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
        ])
        hosting.didMove(toParent: self)
    }
}

// SwiftUI inside a collection view cell, without a hosting controller per cell
cell.contentConfiguration = UIHostingConfiguration {
    OrderRowView(order: order)
}