11 · UITableViewCell 성능 최적화

final class FeedCell: UITableViewCell {
    private let thumbnail = UIImageView()
    private var imageTask: Task<Void, Never>?
    private(set) var representedID: UUID?

    override func prepareForReuse() {
        super.prepareForReuse()
        imageTask?.cancel()            // ✅ 진행 중 다운로드 취소
        imageTask = nil
        thumbnail.image = nil          // ✅ 이전 이미지 제거 (안 하면 깜빡임)
        representedID = nil
        accessoryType = .none          // ✅ 이전 셀의 상태가 남지 않게
        contentView.alpha = 1          // ✅ 애니메이션 중이었을 수 있다
    }

    func configure(_ item: Item, loader: ImageLoader) {
        representedID = item.id
        titleLabel.text = item.title

        imageTask = Task { [weak self] in
            guard let image = try? await loader.image(for: item.imageURL) else { return }
            // ✅ 재사용 검증 — 응답이 늦게 오면 다른 셀이 되어 있을 수 있다
            guard self?.representedID == item.id else { return }
            self?.thumbnail.image = image
        }
    }
}

// ── 최선: 고정 높이 ──
tableView.rowHeight = 88            // 계산 자체가 없다

// ── 차선: 계산해서 캐시 ──
@MainActor
final class HeightCache {
    private var cache: [UUID: CGFloat] = [:]
    private var cachedWidth: CGFloat = 0

    func height(for item: Item, width: CGFloat, font: UIFont) -> CGFloat {
        if width != cachedWidth {           // 회전 등으로 너비가 바뀌면 전부 무효
            cache.removeAll()
            cachedWidth = width
        }
        if let hit = cache[item.id] { return hit }

        let bounding = (item.title as NSString).boundingRect(
            with: CGSize(width: width - 32, height: .greatestFiniteMagnitude),
            options: [.usesLineFragmentOrigin, .usesFontLeading],
            attributes: [.font: font], context: nil)
        let h = ceil(bounding.height) + 24
        cache[item.id] = h
        return h
    }
}

func tableView(_ tv: UITableView, heightForRowAt ip: IndexPath) -> CGFloat {
    heightCache.height(for: items[ip.row], width: tv.bounds.width, font: .preferredFont(forTextStyle: .body))
}

// ── 셀프사이징을 쓸 때는 추정값을 실제와 비슷하게 ──
tableView.rowHeight = UITableView.automaticDimension
tableView.estimatedRowHeight = 88        // 실제와 멀면 스크롤바가 튄다
// 정확한 높이를 직접 준다면 추정을 끄는 게 낫다
tableView.estimatedRowHeight = 0

// ❌ ① DateFormatter를 매번 생성 — 매우 비싸다 (로케일·캘린더 초기화)
func tableView(_ tv: UITableView, cellForRowAt ip: IndexPath) -> UITableViewCell {
    let f = DateFormatter()
    f.dateFormat = "yyyy.MM.dd"
    cell.dateLabel.text = f.string(from: item.date)
    return cell
}
// ✅ 재사용 (또는 iOS 15+ 의 formatted API)
enum Formatters {
    static let date: DateFormatter = {
        let f = DateFormatter()
        f.dateFormat = "yyyy.MM.dd"
        f.locale = Locale(identifier: "ko_KR")
        return f
    }()
}
cell.dateLabel.text = Formatters.date.string(from: item.date)

// ❌ ② NSAttributedString을 매번 생성
cell.body.attributedText = NSAttributedString(string: item.text, attributes: attrs)
// ✅ 캐시
final class TextCache {
    private var cache: [UUID: NSAttributedString] = [:]
    func attributed(_ item: Item) -> NSAttributedString {
        if let hit = cache[item.id] { return hit }
        let s = NSAttributedString(string: item.text, attributes: attrs)
        cache[item.id] = s
        return s
    }
}

// ❌ ③ 디스크 I/O · JSON 파싱 · 정규식 컴파일
let json = try! Data(contentsOf: fileURL)     // 💥 메인 스레드 블로킹

// ❌ ④ 셀 안에서 매번 뷰 생성
cell.contentView.addSubview(UILabel())        // 💥 재사용될수록 쌓인다
// ✅ 셀 init에서 한 번만 만들고 configure에서 값만 바꾼다

import ImageIO
import UIKit

// ✅ 필요한 크기만 디코딩한다 — 원본을 통째로 메모리에 올리지 않는다
func downsample(imageAt url: URL, to pointSize: CGSize, scale: CGFloat) -> UIImage? {
    let srcOptions = [kCGImageSourceShouldCache: false] as CFDictionary
    guard let src = CGImageSourceCreateWithURL(url as CFURL, srcOptions) else { return nil }

    let maxPixel = max(pointSize.width, pointSize.height) * scale
    let options = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,      // 지금 디코딩해 둔다
        kCGImageSourceCreateThumbnailWithTransform: true,
        kCGImageSourceThumbnailMaxPixelSize: maxPixel
    ] as CFDictionary

    guard let cg = CGImageSourceCreateThumbnailAtIndex(src, 0, options) else { return nil }
    return UIImage(cgImage: cg)
}

// 왜 필요한가 — 메모리 계산
// 4000×3000 원본 = 4000 × 3000 × 4바이트 ≈ 48MB (디코딩된 비트맵)
// 100pt 셀 @3x = 300×300 × 4 ≈ 0.36MB
// → 셀 20개면 960MB vs 7MB. Jetsam이 도는 이유가 이거다. (09번)

// ✅ 백그라운드에서 미리 디코딩해 두면 메인 스레드가 안 멈춘다
actor ImagePipeline {
    private let cache = NSCache<NSURL, UIImage>()

    func image(for url: URL, size: CGSize, scale: CGFloat) async -> UIImage? {
        if let hit = cache.object(forKey: url as NSURL) { return hit }
        let img = await Task.detached(priority: .utility) {
            downsample(imageAt: url, to: size, scale: scale)
        }.value
        if let img { cache.setObject(img, forKey: url as NSURL) }
        return img
    }
}

// ✅ ① 불투명하게 — 블렌딩 계산이 사라진다
cell.contentView.isOpaque = true
cell.contentView.backgroundColor = .systemBackground    // 투명이면 의미 없다

// ✅ ② 그림자에는 반드시 shadowPath — 없으면 매번 알파 채널을 스캔한다
layer.shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: 12).cgPath
layer.shadowOpacity = 0.15
layer.shouldRasterize = true                 // 정적이라면
layer.rasterizationScale = UIScreen.main.scale   // ⚠️ 안 주면 흐려진다

// ✅ ③ 계층을 얕게 — 중첩 스택뷰는 제약 수가 빠르게 늘어난다
// ❌ VStack(HStack(VStack(...)))  같은 4중 중첩
// ✅ 정적인 부분은 한 장의 이미지로 합성하거나, 프레임 기반 배치 고려

// ✅ ④ draw(_:)를 구현하지 않는다 — 구현하면 백킹스토어가 생긴다
// ❌ override func draw(_ rect: CGRect) { /* 원 그리기 */ }
// ✅ layer 속성으로 대체
view.layer.cornerRadius = 8
view.backgroundColor = .systemRed

// ⚠️ 정확히 말하기: "cornerRadius는 무조건 느리다"는 옛말이다.
//    단순한 cornerRadius는 최적화되어 있고,
//    masksToBounds·mask·그룹 불투명과 겹칠 때 오프스크린 렌더가 발생한다.
//    확인: Instruments → Core Animation → Color Offscreen-Rendered Yellow

// ✅ 화면에 나타나기 전에 미리 받아 둔다
extension FeedViewController: UITableViewDataSourcePrefetching {
    func tableView(_ tv: UITableView, prefetchRowsAt indexPaths: [IndexPath]) {
        for ip in indexPaths {
            pipeline.prefetch(items[ip.row].imageURL)
        }
    }
    func tableView(_ tv: UITableView, cancelPrefetchingForRowsAt indexPaths: [IndexPath]) {
        for ip in indexPaths {
            pipeline.cancelPrefetch(items[ip.row].imageURL)   // ✅ 취소도 반드시
        }
    }
}
tableView.prefetchDataSource = self

// ✅ Diffable — 인덱스 불일치 크래시가 구조적으로 사라진다
private lazy var dataSource = UITableViewDiffableDataSource<Section, Item.ID>(
    tableView: tableView
) { [weak self] tv, ip, id in
    let cell = tv.dequeueReusableCell(withIdentifier: "cell", for: ip) as! FeedCell
    if let item = self?.itemsByID[id] { cell.configure(item, loader: self!.pipeline) }
    return cell
}

func apply(_ items: [Item], animating: Bool) {
    var snapshot = NSDiffableDataSourceSnapshot<Section, Item.ID>()
    snapshot.appendSections([.main])
    snapshot.appendItems(items.map(\.id))
    dataSource.apply(snapshot, animatingDifferences: animating)
}
// ⚠️ 항목 ID를 쓰면 "내용만 바뀐 경우" 갱신이 안 될 수 있다
//    → reconfigureItems(_:) (iOS 15+) 로 셀 재구성만 요청한다

# ── ① Instruments → Time Profiler ──
#    · 메인 스레드만 필터 (Main Thread)
#    · "Invert Call Tree" 로 실제 시간을 쓰는 리프 함수를 본다
#    · 찾을 이름:
#        layoutSubviews / NSISEngine::...        → Layout 병목
#        -[CALayer display] / CGContext...       → Display 병목
#        CA::Transaction::commit                 → Commit 병목
#        objc_msgSend 가 상위                    → 호출 횟수 자체가 과다
#        swift_retain / swift_release 가 상위    → ARC 과다 (04번)

# ── ② Instruments → Animation Hitches ──
#    hitch 시간과 원인 단계를 직접 보여준다. 가장 빠른 진단.

# ── ③ Core Animation 디버그 옵션 ──
#    Color Blended Layers        → 빨간 영역 = 블렌딩 (isOpaque 확인)
#    Color Offscreen-Rendered    → 노란 영역 = 오프스크린 렌더
#    Color Misaligned Images     → 보라 = 픽셀 정렬 안 됨 (소수점 frame)

# ── ④ os_signpost 로 내 코드 구간 직접 측정 ──

import OSLog

let signposter = OSSignposter(subsystem: "com.app.feed", category: "cell")

func tableView(_ tv: UITableView, cellForRowAt ip: IndexPath) -> UITableViewCell {
    let state = signposter.beginInterval("configureCell", id: signposter.makeSignpostID())
    defer { signposter.endInterval("configureCell", state) }

    let cell = tv.dequeueReusableCell(withIdentifier: "cell", for: ip) as! FeedCell
    cell.configure(items[ip.row], loader: pipeline)
    return cell
}
// Instruments의 os_signpost 트랙에 구간별 시간이 그려진다.
// "cellForRowAt이 평균 0.8ms → 0.2ms로 줄었습니다" 같은 말을 할 수 있게 된다.

import MetricKit

final class MetricsSubscriber: NSObject, MXMetricManagerSubscriber {
    override init() {
        super.init()
        MXMetricManager.shared.add(self)
    }
    func didReceive(_ payloads: [MXMetricPayload]) {
        for p in payloads {
            // 스크롤 끊김의 사용자 지표
            if let hitch = p.animationMetrics?.scrollHitchTimeRatio {
                print("scroll hitch ratio: \(hitch)")
            }
        }
    }
}
// 시뮬레이터·개발 기기 성능은 실사용자와 다르다.
// "구형 기기에서만 끊긴다"를 잡으려면 필드 데이터가 필요하다.

// 항목이 10,000개인 리스트를 생각해 보자

// ❌ 순진한 구현: 항목마다 뷰 하나
//    메모리:   10,000 × (뷰 객체 + 백킹스토어) → 수백 MB → Jetsam (09번)
//    Commit:   레이어 10,000개를 매 프레임 인코딩 → 예산 초과
//    할당:     스크롤 중 계속 malloc/free → 단편화 + ARC 부하

// ✅ 재사용 풀: 화면에 보이는 수 + α 만 유지
//    메모리:   ~15개 × 뷰 → 수 MB
//    Commit:   레이어 ~15개
//    할당:     초기 15회 후 0회 — 스크롤 중 할당이 아예 없다
//
//    ★ 자원 소비가 "데이터 개수 N"이 아니라 "화면 크기"에 비례한다.
//      O(N) → O(1). 이게 재사용의 본질이다.

경성 실시간 (hard real-time)
  데드라인을 놓치면 → 시스템 실패 (에어백, 항공 제어)

연성 실시간 (soft real-time)   ← UI 렌더링이 여기
  데드라인을 놓치면 → 결과의 "가치"가 떨어진다 (끊김, 나쁜 경험)

일반 배치 처리
  데드라인 없음 → 늦어도 결과는 유효하다

// ★ 핵심 차이:
//   배치 작업은 17ms 걸리면 "17ms 늦은 정답"이다.
//   프레임은 17ms 걸리면 "그 프레임을 놓친 것"이다 —
//   늦은 정답이 아니라 아예 표시되지 않는다.
//
//   그리고 다음 VSync까지 기다려야 하므로
//   1ms 초과가 16.7ms 지연으로 증폭된다. 벼랑 효과(cliff)다.

셀 재사용            = 객체 풀링          — 할당 비용을 O(N)→O(1)
높이 캐싱            = 메모이제이션       — 계산을 재사용
prefetching          = 예측적 선반입      — 유휴 시간을 미리 소비
백그라운드 디코딩    = 작업 오프로딩      — 임계 경로에서 빼내기
다운샘플링           = 해상도 축소        — 필요한 만큼만 계산
NSCache              = 캐시 + 방출 정책   — 메모리 압박 시 자동 해제
Diffable snapshot    = 증분 갱신          — 전체 재계산 회피 (12번과 같은 아이디어)
지연 디코딩          = 지연 평가          — 필요할 때까지 미루기 (04번 CoW와 같은 계열)

// ★ 관통하는 원리는 둘뿐이다:
//   ① 임계 경로(critical path)에서 일을 빼낸다 — 미리 / 나중에 / 다른 스레드로
//   ② 같은 일을 두 번 하지 않는다 — 캐시 · 재사용 · 증분