08 · View Lifecycle

final class FeedViewController: UIViewController {
    private let tableView = UITableView()
    private let gradientLayer = CAGradientLayer()
    private var didRestoreScroll = false

    // ───── 1회성: 딱 한 번만 해야 하는 것 ─────
    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(tableView)
        tableView.dataSource = self
        tableView.register(FeedCell.self, forCellReuseIdentifier: "cell")
        view.layer.insertSublayer(gradientLayer, at: 0)
        bindViewModel()
        // ❌ 여기서 tableView.frame = view.bounds 하면 안 된다 — bounds가 아직 임시값
    }

    // ───── 매번: 돌아올 때마다 갱신 ─────
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        navigationController?.setNavigationBarHidden(false, animated: animated)
        viewModel.refresh()
        NotificationCenter.default.addObserver(
            self, selector: #selector(didUpdate),
            name: .feedUpdated, object: nil)
    }

    // ───── 크기 확정 후, 화면에 보이기 전 ─────
    override func viewIsAppearing(_ animated: Bool) {
        super.viewIsAppearing(animated)
        // 여기서는 bounds·safeAreaInsets·traitCollection 이 정확하다
        if !didRestoreScroll {
            didRestoreScroll = true
            tableView.setContentOffset(savedOffset, animated: false)
        }
        // 셀 선택 해제도 여기가 자연스럽다 (전환 애니메이션과 함께 보인다)
        if let ip = tableView.indexPathForSelectedRow {
            tableView.deselectRow(at: ip, animated: animated)
        }
    }

    // ───── 여러 번 불린다 → 반드시 멱등하게 ─────
    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        tableView.frame = view.bounds          // ✅ 대입이라 몇 번 해도 같다
        gradientLayer.frame = view.bounds      // ✅ 멱등
        // ❌ view.addSubview(banner)  ← 부를 때마다 배너가 쌓인다
        // ❌ count += 1               ← 부를 때마다 증가한다
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        NotificationCenter.default.removeObserver(self, name: .feedUpdated, object: nil)
        savedOffset = tableView.contentOffset
    }

    deinit { print("✅ FeedViewController deinit") }   // 릭 확인용
}

// ① viewWillAppear에 1회성 초기화 → 뒤로 갔다 오면 중복
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    sections.append(headerSection)     // 💥 돌아올 때마다 헤더가 늘어난다
}

// ② viewDidLoad에서 bounds로 원형 마스크 → 회전·사이즈 변경 후 깨짐
override func viewDidLoad() {
    super.viewDidLoad()
    avatar.layer.cornerRadius = avatar.bounds.width / 2   // 💥 bounds가 아직 임시
}
// ✅ 크기 확정 후에
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    avatar.layer.cornerRadius = avatar.bounds.width / 2
}

// ③ viewDidLayoutSubviews에서 레이아웃 무효화 → 무한 루프
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    heightConstraint.constant = label.frame.height   // 💥 다시 레이아웃 유발
    view.layoutIfNeeded()                            // 💥 재귀
}

// ④ loadView에서 super 호출 — 직접 뷰를 만들 때는 부르면 안 된다
override func loadView() {
    // super.loadView()      // ❌ 스토리보드/nib 로드가 내 뷰를 덮어쓴다
    view = CustomRootView()  // ✅ 직접 대입
}

// ⑤ deinit이 안 불림 → 순환 참조 (09번 주제)
//    생명주기 디버깅의 1순위 체크는 언제나 deinit 로그다

final class BadgeView: UIView {
    // ① 생성
    override init(frame: CGRect) { super.init(frame: frame); setup() }
    required init?(coder: NSCoder) { super.init(coder: coder); setup() }

    // ② 슈퍼뷰에 붙기 직전 / 직후
    override func willMove(toSuperview newSuperview: UIView?) { }
    override func didMoveToSuperview() { }

    // ③ 윈도우에 붙기 — "화면에 실제로 올라간" 시점
    override func didMoveToWindow() {
        if window != nil { startAnimating() }    // 화면에 붙었다
        else             { stopAnimating() }     // 떨어졌다 → 타이머 정리
    }

    // ④ 레이아웃 — 여러 번 불린다. 멱등해야 한다. 직접 호출 금지
    override func layoutSubviews() {
        super.layoutSubviews()
        dot.frame = CGRect(x: bounds.maxX - 8, y: 0, width: 8, height: 8)
    }

    // ⑤ 그리기 — 구현하면 백킹스토어가 생긴다. 필요 없으면 구현하지 말 것
    // override func draw(_ rect: CGRect) { }

    // ⑥ 크기 협상에 참여
    override var intrinsicContentSize: CGSize { CGSize(width: 24, height: 24) }
}

// ❌ 스크롤하면 타이머가 멈춘다
Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in tick() }
// scheduledTimer 는 .default 모드에만 등록된다.
// 스크롤 중에는 RunLoop가 .tracking 모드로 전환되므로 타이머가 안 돈다.

// ✅ .common 에 추가하면 스크롤 중에도 돈다
let timer = Timer(timeInterval: 1, repeats: true) { _ in tick() }
RunLoop.main.add(timer, forMode: .common)

// 모드는 "지금 이 루프가 어떤 소스들을 처리할지"의 필터다.
//
// ★ 이게 왜 생명주기 이야기인가:
//   viewWillAppear 에서 건 타이머가 "스크롤하면 멈춘다"는 제보로 돌아오는 일이
//   흔하다. 원인은 생명주기 배치가 아니라 이 루프의 모드다.
//   즉 "언제 호출되나"만이 아니라 "그 루프가 지금 무엇을 처리 중인가"까지
//   봐야 콜백 기반 코드의 동작이 설명된다.

print("A")
DispatchQueue.main.async { print("C") }   // 지금 실행 중인 작업이 끝난 뒤
print("B")
// 출력: A B C

// 왜? main.async 는 "메인 큐에 넣는 것"이고,
// 메인 큐는 현재 실행 중인 블록이 끝나야 다음 블록을 꺼낸다.
// → 그래서 "다음 RunLoop 반복에서" 라고 흔히 말하지만,
//   정확히는 "현재 작업이 반환된 뒤 메인 큐의 다음 차례에서" 이다.

// 실무 활용: 레이아웃이 끝난 뒤에 뭔가 하고 싶을 때
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    DispatchQueue.main.async {         // 이번 레이아웃 패스가 끝난 뒤
        self.scrollToBottom()          // 재귀 무효화를 피한다
    }
}

// 배치 프로그램 (전통적 제어 흐름)
func main() {
    let input = readInput()
    let result = process(input)
    print(result)
}   // 내가 흐름을 통제한다. 끝나면 종료.

// GUI 앱 (이벤트 주도)
func main() {
    setup()
    while true {                    // ← UIApplicationMain 이 이 루프를 돈다
        let event = waitForEvent()  // ← 이벤트가 없으면 여기서 잠든다
        dispatch(event)             // ← 등록된 콜백을 부른다
        layoutIfNeeded()
        renderIfNeeded()
    }
}
// 내가 흐름을 통제하지 않는다. 프레임워크가 나를 부른다.
// → 이것이 제어의 역전(Inversion of Control)이고,
//   "생명주기 콜백"이 존재하는 이유다.

앱 코드 (EL0, 특권 없음)
   │  CFRunLoopRun → __CFRunLoopServiceMachPort → mach_msg
   │
   ▼  SVC 명령 (Supervisor Call) — 하드웨어가 특권 수준을 올린다
XNU 커널 (EL1)
   │  · 이 스레드를 실행 큐에서 빼서 포트의 대기 큐로 옮긴다
   │  · 다른 스레드를 스케줄한다  ← 그래서 CPU 사용률이 0%가 된다
   │
   ▼  (터치·타이머·네트워크 완료가 그 포트로 메시지를 보내면)
   │  · 대기 큐에서 스레드를 꺼내 다시 실행 큐로
   ▼  ERET — 특권 수준을 내리고 앱으로 복귀
앱 코드 (EL0) — mach_msg 가 반환되고, RunLoop가 이벤트를 처리한다

// ARM64는 EL0(앱) / EL1(커널) / EL2(하이퍼바이저) / EL3(보안 모니터)로 나뉜다.
// "앱이 잠든다"는 표현이 실제로는 이 왕복 한 번이다.
//
// ⚠️ 정밀하게: mach_msg 는 BSD 시스템 콜이 아니라 Mach trap 이다.
//    Darwin은 두 계열의 트랩을 갖는다 — BSD syscall(read/write 등)과
//    Mach trap(포트·메시지·VM 등). 둘 다 svc 명령으로 EL0→EL1로 넘어가지만
//    커널 안에서 다른 테이블로 분기한다.
//    "시스템 콜"이라고 뭉뚱그려도 대화는 통하지만, 구분해서 말하면 한 층 더 들어간 게 된다.

# 앱이 유휴 상태일 때 메인 스레드 스택을 떠 보면
# 항상 이 모양의 바닥이 보인다

Thread 0 (main):
  0  libsystem_kernel.dylib  mach_msg2_trap          ← 커널에서 블로킹 중
  1  libsystem_kernel.dylib  mach_msg
  2  CoreFoundation          __CFRunLoopServiceMachPort
  3  CoreFoundation          __CFRunLoopRun
  4  CoreFoundation          CFRunLoopRunSpecific
  5  GraphicsServices        GSEventRunModal
  6  UIKitCore               UIApplicationMain
  7  MyApp                   main

# Xcode 디버거에서 일시 정지하거나, Instruments의 Time Profiler로 확인 가능.
# "메인 스레드가 블록됐다"는 말의 의미도 여기서 명확해진다 —
# mach_msg 가 아니라 "내 코드"가 스택 맨 위에 오래 남아 있는 상태다.

            ┌──────────────┐
   init ──▶ │  NotLoaded   │
            └──────┬───────┘
                   │ loadView + viewDidLoad   ← 이 간선은 한 번만 지난다
                   ▼
            ┌──────────────┐
       ┌───▶│    Loaded    │◀────┐
       │    └──────┬───────┘     │
       │           │ viewWillAppear / viewIsAppearing
       │           ▼             │ viewDidDisappear
       │    ┌──────────────┐     │
       │    │  Appearing   │─────┤  ← 전환 취소 시 여기서 되돌아온다
       │    └──────┬───────┘     │
       │           │ viewDidAppear
       │           ▼             │
       │    ┌──────────────┐     │
       └────│   Appeared   │─────┘
  viewWillDisappear └──────┘

// 이 그래프로 함정 두 개가 즉시 설명된다:
//   ① NotLoaded → Loaded 간선은 1회뿐이다
//        → viewDidLoad에 1회성을 넣는 것이 "맞는" 이유
//   ② Loaded ⇄ Appearing ⇄ Appeared 는 사이클이다
//        → viewWillAppear에 1회성을 넣으면 사이클을 돌 때마다 반복된다
//   ③ Appearing → Loaded 로 되돌아오는 간선이 존재한다
//        → 전환 취소 시 viewDidAppear 없이 viewWillDisappear가 오는 이유

struct ProfileView: View {
    let userID: String
    @State private var draft = ""          // 이 상태의 수명은 "뷰 값"이 아니라 identity에 매달린다

    var body: some View {                  // body는 수시로 재계산된다 — 이건 "생성"이 아니다
        TextField("메모", text: $draft)
            .task(id: userID) {            // identity가 바뀌면 취소되고 재시작
                await load(userID)
            }
    }
}

// ① 뷰는 객체가 아니라 값(struct)이다. body 재계산 ≠ 화면 재생성
// ② @State의 수명은 structural identity (타입 + 뷰 트리 위치) 가 정한다
// ③ .id() 로 identity를 바꾸면 @State가 초기화된다 — "재생성"의 유일한 방법
// ④ onAppear/onDisappear 는 UIKit 생명주기와 1:1이 아니다

// 그래서 UIKit 습관이 이렇게 번역된다
//   viewDidLoad   → .task { }  또는 초기화 시점 (단, 여러 번 불릴 수 있음)
//   viewWillAppear → .onAppear { }
//   viewDidLayoutSubviews → GeometryReader / onGeometryChange
//   "화면을 리셋" → .id(newValue) 로 identity 교체