13 · 캐시와 성능 설계

import Foundation

// 캐시는 언제든 사라질 수 있는 '사본'이다.
// 진실 원본(source of truth)을 캐시에 두면 그게 사라지는 순간 데이터 유실이다.

// ❌ 사용자가 작성 중인 글을 캐시에
final class BadDraftCache {
    private let cache = NSCache<NSString, NSString>()   // 💥 메모리 압박에 사라진다
    func save(_ text: String, id: String) {
        cache.setObject(text as NSString, forKey: id as NSString)
    }
}

// ✅ 원본은 영속 저장소에, 캐시는 그 파생물만
final class DraftStore {
    private let disk: URL                                // 원본
    private let memory = NSCache<NSString, NSString>()   // 빠른 조회용 사본

    init(disk: URL) { self.disk = disk }

    func save(_ text: String, id: String) throws {
        try text.write(to: disk.appendingPathComponent(id),
                       atomically: true, encoding: .utf8)   // ✅ 원본 먼저
        memory.setObject(text as NSString, forKey: id as NSString)
    }

    func load(id: String) -> String? {
        if let hit = memory.object(forKey: id as NSString) { return hit as String }
        // ✅ 캐시가 비어도 원본에서 복구된다
        guard let text = try? String(contentsOf: disk.appendingPathComponent(id),
                                     encoding: .utf8) else { return nil }
        memory.setObject(text as NSString, forKey: id as NSString)
        return text
    }
}

// ✅ 캐시해도 되는 것 판별
//   · 서버에서 다시 받을 수 있다              → 캐시 OK
//   · 원본 데이터로 다시 계산할 수 있다        → 캐시 OK
//   · 사라지면 복구 경로가 없다               → 캐시 ✗ (저장소로)
//
// 예: 디코딩된 이미지 ✅ / 계산된 레이아웃 ✅ / 서버 응답 ✅
//     작성 중인 글 ✗ / 오프라인 큐 ✗ / 사용자 설정 ✗

import Foundation

// 캐시를 추가하기 전에 답해야 하는 질문:
//   "이 항목은 무엇이 바뀌면, 어떻게 사라지나?"
// 답이 없으면 아직 넣을 때가 아니다.

/// 프로필 캐시
/// - 무효화 조건:
///   ① 사용자가 프로필을 수정 → 즉시 invalidate(userID)
///   ② 팔로우/언팔로우      → 즉시 invalidate(userID)
///   ③ 그 외 서버 변경      → TTL 5분으로 자연 만료 (안전망)
/// - 스코프: 로그아웃 시 전체 삭제
actor ProfileCache {
    private struct Entry { let profile: Profile; let expiresAt: Date }
    private var storage: [String: Entry] = [:]
    private let ttl: TimeInterval = 300

    func profile(for id: String) -> Profile? {
        guard let e = storage[id], e.expiresAt > Date() else {
            storage[id] = nil
            return nil
        }
        return e.profile
    }

    func store(_ profile: Profile, for id: String) {
        storage[id] = Entry(profile: profile,
                            expiresAt: Date().addingTimeInterval(ttl))
    }

    // ✅ 무효화 경로를 명시적으로 노출한다
    func invalidate(_ id: String) { storage[id] = nil }
    func invalidateAll() { storage.removeAll() }
}

// ✅ 무효화 호출 지점을 한곳에 모아 두면 빠뜨리기 어려워진다
enum CacheInvalidation {
    static func onProfileUpdated(_ id: String) async {
        await ProfileCacheRef.shared.invalidate(id)
        await FeedCacheRef.shared.invalidateAuthor(id)     // 연쇄 무효화도 여기서
    }
    static func onLogout() async {
        await ProfileCacheRef.shared.invalidateAll()
        await FeedCacheRef.shared.invalidateAll()
    }
}

struct Profile {}
enum ProfileCacheRef { static let shared = ProfileCache() }
actor FeedCacheImpl {
    func invalidateAuthor(_ id: String) {}
    func invalidateAll() {}
}
enum FeedCacheRef { static let shared = FeedCacheImpl() }

import Foundation

// 앱을 업데이트해 응답 포맷이 바뀌면, 옛 캐시가 새 코드에 잘못 디코딩되거나
// 조용히 이상한 값을 준다. 키에 버전을 넣으면 옛 캐시가 자동으로 미아가 된다.

enum CacheKey {
    /// 응답 스키마를 바꿀 때마다 올린다
    private static let schemaVersion = 3

    /// 앱 빌드가 바뀌면 무효화하고 싶은 캐시용
    private static var buildVersion: String {
        Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "0"
    }

    static func feed(userID: String) -> String {
        "v\(schemaVersion).feed.\(userID)"
    }

    static func layout(itemID: String, width: Int) -> String {
        // 레이아웃 캐시는 빌드마다 무효화 (폰트·디자인 변경 반영)
        "b\(buildVersion).layout.\(itemID).\(width)"
    }

    static func image(url: URL, size: CGSize, scale: CGFloat) -> String {
        "v\(schemaVersion).img.\(url.absoluteString).\(Int(size.width * scale))x\(Int(size.height * scale))"
    }
}

// ✅ 디스크 캐시는 버전이 바뀌면 옛 디렉터리를 통째로 지운다
func migrateDiskCache(currentVersion: Int, root: URL) throws {
    let fm = FileManager.default
    let current = root.appendingPathComponent("v\(currentVersion)")
    try fm.createDirectory(at: current, withIntermediateDirectories: true)

    // 다른 버전 디렉터리는 정리한다
    for entry in try fm.contentsOfDirectory(at: root, includingPropertiesForKeys: nil) {
        if entry.lastPathComponent != "v\(currentVersion)" {
            try? fm.removeItem(at: entry)
        }
    }
}

// ⚠️ 사용자 데이터가 아니라 '캐시'이므로 통째로 지워도 안전하다.
//    이 판단이 성립하지 않으면 그건 캐시가 아니다(→ 첫 번째 항목).

import Foundation

// 개인정보·인증 관련 데이터를 무기한 캐시하면, 로그아웃 후에도
// 기기에 남아 다음 사용자나 기기 탈취자에게 노출된다.

actor SensitiveCache {
    private struct Entry { let value: Data; let expiresAt: Date }
    private var storage: [String: Entry] = [:]

    /// ✅ 민감 데이터는 TTL을 반드시 둔다 (그리고 짧게)
    private let ttl: TimeInterval = 120

    func value(for key: String) -> Data? {
        guard let e = storage[key], e.expiresAt > Date() else {
            storage[key] = nil; return nil
        }
        return e.value
    }

    func store(_ value: Data, for key: String) {
        storage[key] = Entry(value: value, expiresAt: Date().addingTimeInterval(ttl))
    }

    /// ✅ 로그아웃·세션 종료 시 전체 삭제 경로가 반드시 있어야 한다
    func purgeAll() { storage.removeAll() }
}

// ✅ 세션 종료 시 모든 민감 캐시를 한 번에 지운다
enum SessionTeardown {
    static func onLogout() async {
        await SensitiveCacheRef.shared.purgeAll()
        URLCache.shared.removeAllCachedResponses()        // HTTP 캐시도
        HTTPCookieStorage.shared.removeCookies(since: .distantPast)
        try? FileManager.default.removeItem(at: profileImageCacheDir)
    }
}

// ⚠️ 놓치기 쉬운 자리들
//   · URLCache — 인증된 응답이 디스크에 남는다
//   · 쿠키 저장소
//   · 웹뷰의 WKWebsiteDataStore
//   · 프로필 이미지 등 개인 식별 가능한 파일 캐시
//   · 앱 전환 스냅샷 (민감 화면은 가려야 한다)

// ✅ 애초에 캐시하지 않는 선택도 있다 — ephemeral 세션
func sensitiveSession() -> URLSession {
    URLSession(configuration: .ephemeral)   // 디스크 캐시·쿠키·자격증명 저장 없음
}

enum SensitiveCacheRef { static let shared = SensitiveCache() }
let profileImageCacheDir = URL(fileURLWithPath: NSTemporaryDirectory() + "profiles")

import UIKit

// L1(메모리) → L2(디스크) → 원본. 각 계층의 역할과 승격 규칙을 코드에 드러낸다.

actor TwoTierCache {
    private let memory = NSCache<NSString, UIImage>()     // 뜨겁고 작은 것
    private let diskRoot: URL                             // 크고 차갑고 재생성 비싼 것

    init(diskRoot: URL) {
        self.diskRoot = diskRoot
        memory.countLimit = 200
        memory.totalCostLimit = 48 * 1024 * 1024
    }

    func image(for key: String, fetch: () async throws -> Data) async throws -> UIImage? {
        let nsKey = key as NSString

        // ① 메모리
        if let hit = memory.object(forKey: nsKey) { return hit }

        // ② 디스크 → 히트하면 메모리로 승격
        let fileURL = diskRoot.appendingPathComponent(key)
        if let data = try? Data(contentsOf: fileURL), let image = UIImage(data: data) {
            // cost는 '메모리에 얹히는 크기' — 압축 파일 크기(data.count)를 넣으면
            // 예산이 10~20배 어긋나 48MB 상한이 수백 MB로 무력화된다
            let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
            memory.setObject(image, forKey: nsKey, cost: cost)   // ✅ 승격
            return image
        }

        // ③ 원본 → 두 계층 모두에 채운다
        let data = try await fetch()
        guard let image = UIImage(data: data) else { return nil }
        memory.setObject(image, forKey: nsKey,
                         cost: Int(image.size.width * image.size.height * image.scale * image.scale * 4))
        try? data.write(to: fileURL, options: .atomic)
        return image
    }

    /// 메모리만 비운다 (메모리 경고 시)
    func purgeMemory() { memory.removeAllObjects() }

    /// 디스크까지 비운다 (로그아웃·버전 변경 시)
    func purgeAll() throws {
        memory.removeAllObjects()
        try FileManager.default.removeItem(at: diskRoot)
        try FileManager.default.createDirectory(at: diskRoot, withIntermediateDirectories: true)
    }
}

// 판단표
//   자주 쓰고 작고 재생성 싸다  → 메모리만
//   가끔 쓰고 크고 재생성 비싸다 → 디스크만
//   자주 쓰고 재생성 비싸다      → 둘 다 (승격 규칙 명시)

import Foundation

// 이 둘을 섞으면 두 방향으로 사고가 난다.
//   캐시를 Documents에 → 백업이 불필요하게 커지고 심사에서 지적된다
//   사용자 데이터를 Caches에 → 어느 날 사라지고 복구 불가

enum CachePaths {
    private static let fm = FileManager.default

    /// 이미지·응답 캐시 — 백업 제외 자동, OS가 지울 수 있다
    static func imageCache() throws -> URL {
        let caches = try fm.url(for: .cachesDirectory, in: .userDomainMask,
                                appropriateFor: nil, create: true)
        let dir = caches.appendingPathComponent("images", isDirectory: true)
        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
        return dir
    }

    /// 오프라인 지도처럼 '캐시지만 사라지면 곤란한' 것
    /// → Documents에 두되 백업에서 명시적으로 제외한다
    static func offlineMaps() throws -> URL {
        let docs = try fm.url(for: .documentDirectory, in: .userDomainMask,
                              appropriateFor: nil, create: true)
        var dir = docs.appendingPathComponent("maps", isDirectory: true)
        try fm.createDirectory(at: dir, withIntermediateDirectories: true)

        var values = URLResourceValues()
        values.isExcludedFromBackup = true          // ✅ 백업은 제외
        try dir.setResourceValues(values)           //    하지만 OS가 지우지도 않는다
        return dir
    }

    /// 사용자가 만든 것 — 백업 대상
    static func userDocuments() throws -> URL {
        try fm.url(for: .documentDirectory, in: .userDomainMask,
                   appropriateFor: nil, create: true)
    }
}

// ⚠️ 세 번째 경우가 헷갈린다: "캐시인데 사라지면 안 되는 것"
//    (오프라인 다운로드 콘텐츠, 미리 받은 지도 타일 등)
//    → Caches는 위험하다. Caches는 위험하다. 앱이 만든 지원 파일이면 Library/Application Support + isExcludedFromBackup이 맞고, 사용자가 직접 받아 관리하는 콘텐츠라면 Documents + isExcludedFromBackup을 쓴다.

// ✅ 현재 사용량을 확인하는 방법
func directorySize(_ url: URL) throws -> Int {
    let keys: Set<URLResourceKey> = [.fileSizeKey]
    guard let e = FileManager.default.enumerator(at: url,
                                                 includingPropertiesForKeys: Array(keys))
    else { return 0 }
    var total = 0
    for case let f as URL in e {
        total += (try? f.resourceValues(forKeys: keys).fileSize) ?? 0
    }
    return total
}

import Foundation

// 상한이 없으면 사용자 저장공간을 계속 먹는다.
// "이 앱이 왜 3GB나 차지하죠?"는 대부분 정리 없는 디스크 캐시 때문이다.

actor DiskCache {
    private let root: URL
    private let maxBytes: Int

    init(root: URL, maxBytes: Int = 200 * 1024 * 1024) throws {
        self.root = root
        self.maxBytes = maxBytes
        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
    }

    func store(_ data: Data, for key: String) throws {
        try data.write(to: root.appendingPathComponent(key), options: .atomic)
    }

    func load(_ key: String) -> Data? {
        let url = root.appendingPathComponent(key)
        // ✅ 수정 시각을 touch해 LRU 기준을 갱신한다
        //    (FileAttributeKey에는 접근 시각용 키가 없으므로 trim도 같은 수정 시각으로 정렬해야 한다)
        try? FileManager.default.setAttributes([.modificationDate: Date()],
                                               ofItemAtPath: url.path)
        return try? Data(contentsOf: url)
    }

    /// 오래 안 쓴 것부터 지워 상한 이하로 맞춘다
    func trim() throws {
        let keys: Set<URLResourceKey> = [.contentModificationDateKey, .fileSizeKey]
        let files = try FileManager.default.contentsOfDirectory(
            at: root, includingPropertiesForKeys: Array(keys))

        var entries = files.compactMap { url -> (URL, Date, Int)? in
            guard let v = try? url.resourceValues(forKeys: keys) else { return nil }
            return (url, v.contentModificationDate ?? .distantPast, v.fileSize ?? 0)
        }

        var total = entries.reduce(0) { $0 + $1.2 }
        guard total > maxBytes else { return }

        entries.sort { $0.1 < $1.1 }                     // 오래된 것 먼저
        for (url, _, size) in entries {
            guard total > maxBytes else { break }
            try? FileManager.default.removeItem(at: url)
            total -= size
        }
    }
}

// ✅ trim을 부르는 시점: 앱 백그라운드 진입, 주기적 유지보수 작업
// ✅ 사용자에게 캐시 용량과 삭제 버튼을 제공하는 것도 좋은 관행이다

import Foundation

// 사용자가 방금 바꾼 것이 화면에 안 보이면 그건 버그로 인식된다.
// 이런 데이터는 이벤트 발생 즉시 캐시를 지운다.

actor OrderCache {
    private struct Entry { let order: Order; let expiresAt: Date }
    private var storage: [String: Entry] = [:]

    /// 결제·주문 상태는 TTL을 짧게 (안전망)
    private let ttl: TimeInterval = 30

    func order(_ id: String) -> Order? {
        guard let e = storage[id], e.expiresAt > Date() else {
            storage[id] = nil; return nil
        }
        return e.order
    }

    func store(_ order: Order) {
        storage[order.id] = Entry(order: order,
                                  expiresAt: Date().addingTimeInterval(ttl))
    }

    // ✅ 1순위 — 상태가 바뀌는 모든 경로에서 즉시 호출한다
    func invalidate(_ id: String) { storage[id] = nil }
}

// ✅ 무효화 호출 지점을 빠짐없이 배선한다
@MainActor
final class OrderCoordinator {
    private let cache = OrderCache()

    func cancelOrder(_ id: String) async throws {
        try await api.cancel(id)
        await cache.invalidate(id)              // ① 내 액션
    }

    func handlePush(_ payload: [String: Any]) async {
        if let id = payload["orderID"] as? String {
            await cache.invalidate(id)          // ② 서버 푸시
        }
    }

    func onForeground() async {
        await cache.invalidate("current")       // ③ 복귀 시 최신화
    }
}

// ⚠️ ①②③ 중 하나라도 빠지면 그 경로에서 stale이 남는다.
//    그래서 짧은 TTL을 안전망으로 함께 둔다.

struct Order { let id: String }
enum api { static func cancel(_ id: String) async throws {} }

import Foundation

// 국가 목록·약관·아이콘 세트처럼 몇 달에 한 번 바뀌는 데이터에
// 실시간 무효화를 배선하는 건 과설계다.

actor StaticDataCache {
    private struct Entry<T> { let value: T; let expiresAt: Date }
    private var countries: Entry<[Country]>?

    /// 하루 — 이 정도면 충분하다
    private let ttl: TimeInterval = 60 * 60 * 24

    func countries(fetch: () async throws -> [Country]) async throws -> [Country] {
        if let e = countries, e.expiresAt > Date() { return e.value }
        let fresh = try await fetch()
        countries = Entry(value: fresh, expiresAt: Date().addingTimeInterval(ttl))
        return fresh
    }
}

// ✅ 여기에 재검증(ETag)을 얹으면 "만료됐지만 사실 안 바뀐" 경우의 낭비도 없앤다
struct ConditionalFetch {
    private var etag: String?

    mutating func fetch(_ url: URL) async throws -> Data? {
        var request = URLRequest(url: url)
        if let etag { request.setValue(etag, forHTTPHeaderField: "If-None-Match") }

        let (data, response) = try await URLSession.shared.data(for: request)
        guard let http = response as? HTTPURLResponse else { return data }

        if http.statusCode == 304 { return nil }          // ⚠️ URLCache가 붙은 세션은 304를 200 + 캐시 본문으로 바꿔 돌려준다.
            //    직접 304를 다루려면 urlCache = nil 인 세션을 쓰거나 재검증을 URLSession에 맡긴다
        etag = http.value(forHTTPHeaderField: "ETag")
        return data
    }
}

// ✅ URLSession의 HTTP 캐시가 이걸 자동으로 해 준다 (서버가 헤더를 주면)
func cacheAwareSession() -> URLSession {
    let config = URLSessionConfiguration.default
    config.requestCachePolicy = .useProtocolCachePolicy   // Cache-Control·ETag 준수
    config.urlCache = URLCache(memoryCapacity: 16 << 20, diskCapacity: 128 << 20)
    return URLSession(configuration: config)
}
// 서버가 Cache-Control: max-age=86400을 주면 클라 코드 없이도 캐시된다

struct Country: Decodable {}

import Foundation

// 무효화는 '모든 변경 경로를 빠짐없이 배선했을 때만' 정확하다.
// 이벤트 하나만 유실돼도 그 항목은 영구 stale이 된다.

// 이벤트가 유실되는 실제 경로들
//   · 푸시 알림 미수신 (권한 거부, 네트워크, 시스템 스로틀)
//   · 앱 강제 종료 중 발생한 변경
//   · 웹소켓 연결 끊김 구간
//   · 다른 기기에서의 변경
//   · 무효화 호출을 빠뜨린 새 코드 경로 (가장 흔하다)

actor ResilientCache<T> {
    private struct Entry { let value: T; let storedAt: Date }
    private var storage: [String: Entry] = [:]

    /// 명시적 무효화가 1순위, TTL은 그게 실패했을 때의 안전망
    private let safetyNetTTL: TimeInterval

    init(safetyNetTTL: TimeInterval = 300) {
        self.safetyNetTTL = safetyNetTTL
    }

    func value(for key: String) -> T? {
        guard let e = storage[key] else { return nil }
        // ✅ 이벤트를 놓쳤어도 여기서 스스로 회복한다
        guard Date().timeIntervalSince(e.storedAt) < safetyNetTTL else {
            storage[key] = nil
            return nil
        }
        return e.value
    }

    func store(_ value: T, for key: String) {
        storage[key] = Entry(value: value, storedAt: Date())
    }

    func invalidate(_ key: String) { storage[key] = nil }
}

// ✅ TTL 길이를 정하는 기준
//   "이 데이터가 최대 얼마나 낡아 있어도 사용자가 납득하는가?"
//     주문 상태     → 30초
//     프로필        → 5분
//     피드 목록     → 2분
//     국가 목록     → 24시간
//
// ⚠️ TTL은 '정확도'를 위한 게 아니라 '자가 치유'를 위한 장치다.
//    둘은 대체재가 아니라 보완재다.

final class ImageCache {
    // 값은 참조 타입(UIImage), 키는 NSString — 값 타입은 그대로 못 넣음
    private let cache = NSCache<NSString, UIImage>()

    init() {
        cache.countLimit = 200                  // soft limit: 권고치일 뿐 강제 아님
        cache.totalCostLimit = 50 * 1024 * 1024 // cost 합의 상한(여기선 바이트로 해석)
    }

    func image(for key: String) -> UIImage? {
        cache.object(forKey: key as NSString)   // 락 없이 스레드 안전
    }

    func insert(_ image: UIImage, for key: String, bytes: Int) {
        cache.setObject(image, forKey: key as NSString, cost: bytes)
    }
}

import UIKit

// Dictionary로 캐시를 짜면 락·축출·메모리 경고 대응을 전부 직접 만들어야 한다.

// ❌ 직접 만들면 빠뜨리는 것들
final class NaiveCache {
    private var storage: [String: UIImage] = [:]
    // 스레드 안전 ✗  축출 ✗  메모리 경고 대응 ✗  비용 기반 상한 ✗
    func set(_ image: UIImage, _ key: String) { storage[key] = image }
}

// ✅ NSCache는 이 넷을 다 해 준다
final class ImageCache {
    private let cache = NSCache<NSString, UIImage>()

    init() {
        cache.countLimit = 300
        cache.totalCostLimit = 64 * 1024 * 1024
        cache.name = "com.app.images"
        // evictsObjectsWithDiscardedContent는 기본 true
    }

    func image(for key: String) -> UIImage? {
        cache.object(forKey: key as NSString)
    }

    func store(_ image: UIImage, for key: String) {
        // ✅ cost는 '바이트 수'로 넣어야 totalCostLimit이 의미를 갖는다
        let bytes = Int(image.size.width * image.size.height
                        * image.scale * image.scale * 4)
        cache.setObject(image, forKey: key as NSString, cost: bytes)
    }
}

// ✅ 축출 시점을 관찰하고 싶으면 delegate를 붙인다
final class ObservableCache: NSObject, NSCacheDelegate {
    private let cache = NSCache<NSString, UIImage>()

    override init() {
        super.init()
        cache.delegate = self
    }

    func cache(_ cache: NSCache<AnyObject, AnyObject>, willEvictObject obj: Any) {
        // ⚠️ 여기서 obj의 키는 알 수 없다. 통계 수집 정도로만 쓴다.
        print("축출됨")
    }
}

// ⚠️ NSCache는 '자동 정리'를 시스템에 맡긴다. 정확한 시점·개수는 보장되지 않는다.

import Foundation

// NSCache는 참조 타입만 담는다(NSObject 기반). Swift 값 타입은 래핑이 필요하다.

// ✅ 범용 박스
final class Box<T>: NSObject {
    let value: T
    init(_ value: T) { self.value = value }
}

// ✅ 키도 NSString이어야 한다
final class TypedCache<Value> {
    private let cache = NSCache<NSString, Box<Value>>()

    init(countLimit: Int = 200, totalCostLimit: Int = 0) {
        cache.countLimit = countLimit
        if totalCostLimit > 0 { cache.totalCostLimit = totalCostLimit }
    }

    subscript(key: String) -> Value? {
        get { cache.object(forKey: key as NSString)?.value }
        set {
            guard let newValue else {
                cache.removeObject(forKey: key as NSString); return
            }
            cache.setObject(Box(newValue), forKey: key as NSString)
        }
    }

    func set(_ value: Value, for key: String, cost: Int) {
        cache.setObject(Box(value), forKey: key as NSString, cost: cost)
    }

    func removeAll() { cache.removeAllObjects() }
}

// 사용
struct Layout { let height: CGFloat; let lineCount: Int }
let layoutCache = TypedCache<Layout>(countLimit: 500)

func cachedLayout(for id: String, compute: () -> Layout) -> Layout {
    if let hit = layoutCache[id] { return hit }
    let fresh = compute()
    layoutCache[id] = fresh
    return fresh
}

// ⚠️ 래핑 비용을 감안한다 — 값마다 클래스 인스턴스 하나가 힙에 생긴다.
//    아주 작은 값을 수십만 개 캐시한다면 그 오버헤드가 무시할 수 없다.
//    그 경우엔 직접 만든 딕셔너리 + 락 + 수동 축출이 나을 수도 있다.

// ✅ Swift 6에서는 값 타입 전용 캐시를 actor로 만드는 것도 좋은 선택이다
actor ValueCache<Key: Hashable, Value> {
    private var storage: [Key: Value] = [:]
    private let limit: Int
    private var order: [Key] = []           // 단순 LRU

    init(limit: Int) { self.limit = limit }

    func value(for key: Key) -> Value? {
        guard let v = storage[key] else { return nil }
        order.removeAll { $0 == key }; order.append(key)
        return v
    }

    func store(_ value: Value, for key: Key) {
        storage[key] = value
        order.removeAll { $0 == key }; order.append(key)
        while order.count > limit {
            storage[order.removeFirst()] = nil
        }
    }
}

import UIKit

// countLimit·totalCostLimit은 soft limit이다. 정확히 지켜지지 않고,
// 시스템 판단으로 언제든 전부 비워질 수 있다.

// ❌ 캐시에 있다고 가정하는 코드
final class BadViewModel {
    private let cache = NSCache<NSString, UIImage>()

    func image(for id: String) -> UIImage {
        cache.object(forKey: id as NSString)!      // 💥 언제든 nil이 될 수 있다
    }
}

// ✅ 항상 "없으면 다시 만든다" 경로가 함께 있어야 한다
final class ViewModel {
    private let cache = NSCache<NSString, UIImage>()

    func image(for id: String, source: URL) async -> UIImage? {
        if let hit = cache.object(forKey: id as NSString) { return hit }

        // ✅ 미스는 정상 경로다 — 예외가 아니다
        // ⚠️ 원격 URL에 동기 Data(contentsOf:)는 Apple이 명시적으로 금지한다
        //    (협력 스레드 풀을 통째로 블로킹한다)
        guard let (data, _) = try? await URLSession.shared.data(from: source),
              let image = UIImage(data: data) else { return nil }

        cache.setObject(image, forKey: id as NSString,
                        cost: Int(image.size.width * image.size.height * image.scale * image.scale * 4))
        return image
    }
}

// ⚠️ 이런 기대는 전부 틀렸다
//   · "countLimit을 200으로 뒀으니 정확히 200개가 유지된다"
//     → 더 담길 수도, 더 일찍 비워질 수도 있다
//   · "메모리 경고 때 전부 비운다"
//     → 축출하긴 하지만 얼마나·언제는 보장되지 않는다
//   · "내가 넣은 건 내가 지우기 전까지 있다"
//     → 시스템이 언제든 가져간다

// ✅ 사라져도 정상인 것만 담는다
//    담아도 되는 것: 디코딩된 이미지, 계산된 레이아웃, 파싱 결과
//    담으면 안 되는 것: 작성 중인 글, 오프라인 큐, 결제 진행 상태

// ✅ 반드시 유지돼야 하는 것은 디스크나 DB로
func mustPersist(_ draft: String, to url: URL) throws {
    try draft.write(to: url, atomically: true, encoding: .utf8)
}

final class MemoryImageCache {
    private let cache = NSCache<NSString, UIImage>()
    private var token: NSObjectProtocol?

    init() {
        // NSCache는 자동 축출되지만, 직접 만든 버퍼가 있다면 이렇게 수동 대응
        token = NotificationCenter.default.addObserver(
            forName: UIApplication.didReceiveMemoryWarningNotification,
            object: nil, queue: .main
        ) { [weak self] _ in
            self?.cache.removeAllObjects()   // 재생성 가능 → 즉시 비움
        }
    }
}

// Scene 델리게이트
func sceneDidEnterBackground(_ scene: UIScene) {
    persistDraft()          // 저장 안 된 사용자 입력 = 절대 버리지 않고 먼저 저장
    releaseDecodedImages()  // footprint 축소 → jetsam 확률 감소
    // 디스크 캐시는 유지, 너무 크면 trim
}

import UIKit

// 메모리 경고는 "지금 RAM을 내놓으라"는 신호다.
// 디스크 캐시까지 지우면 다시 채우는 비용만 크고 RAM 확보에는 도움이 안 된다.

@MainActor
final class CacheCoordinator {
    private var memoryCaches: [MemoryPurgeable] = []

    init() {
        NotificationCenter.default.addObserver(
            forName: UIApplication.didReceiveMemoryWarningNotification,
            object: nil, queue: .main) { [weak self] _ in
            self?.handleMemoryWarning()
        }
    }

    func register(_ cache: MemoryPurgeable) { memoryCaches.append(cache) }

    private func handleMemoryWarning() {
        let before = os_proc_available_memory()

        // ✅ 메모리 캐시만 비운다
        memoryCaches.forEach { $0.purgeMemory() }

        // ⚠️ 디스크 캐시는 건드리지 않는다 — RAM과 무관하고 재생성 비용만 크다
        // diskCache.purge()   ← 하지 말 것

        let after = os_proc_available_memory()
        print("메모리 경고 대응: \((after - before) / 1024 / 1024)MB 회수")
    }
}

protocol MemoryPurgeable: AnyObject {
    func purgeMemory()
}

// 각 캐시가 자기 역할만 구현한다
final class ImageCache: MemoryPurgeable {
    private let memory = NSCache<NSString, UIImage>()
    func purgeMemory() { memory.removeAllObjects() }        // ✅ 메모리만
}

final class LayoutCache: MemoryPurgeable {
    private var heights: [String: CGFloat] = [:]
    func purgeMemory() { heights.removeAll() }              // ✅ 다시 계산 가능
}

// ⚠️ 경고에 응답하지 않으면 확보가 저절로 생기는 게 아니라,
//    응답하지 못한 그 앱이 종료 후보가 된다.

import UIKit

// 순서가 중요하다. 먼저 비우고 저장하려 하면 저장할 게 이미 없다.

@MainActor
final class BackgroundHandler {

    func sceneDidEnterBackground() {
        // ✅ ① 저장 안 된 사용자 입력을 먼저 영속화한다
        DraftStore.shared.saveAll()
        try? CoreDataStack.shared.saveIfNeeded()
        UserDefaults.standard.set(currentScrollOffset, forKey: "feed.offset")

        // ✅ ② 쥐고 있던 시스템 자원을 놓는다 (0xdead10cc 예방)
        Database.shared.closeConnections()

        // ✅ ③ 그다음 footprint를 낮춘다
        //    백그라운드 앱이 jetsam 1순위이고, footprint가 큰 앱부터 죽는다
        ImageCache.shared.purgeMemory()
        snapshotCache.removeAll()
        decodedBuffers.removeAll()

        // ✅ ④ 큰 뷰 계층의 백킹스토어도 놓을 수 있다
        window?.rootViewController?.view.layer.contents = nil   // ⚠️ 이건 그 레이어 한 장에만 적용되고 복귀 시 빈 화면 위험이 있다.
        //    실제로 큰 픽셀 버퍼를 쥔 캐시(디코딩 이미지·스냅샷)를 놓는 편이 낫다
    }

    func sceneWillEnterForeground() {
        Database.shared.reopen()
        // 캐시는 필요할 때 다시 채워진다 — 미리 복구하지 않는다
    }

    private var snapshotCache: [String: UIImage] = [:]
    private var decodedBuffers: [Data] = []
    private var currentScrollOffset: Double = 0
    private var window: UIWindow?
}

// ⚠️ 백그라운드 진입 콜백은 시간이 제한적이다(수 초).
//    긴 작업이 필요하면 beginBackgroundTask로 유예를 요청하되,
//    그 안에서도 정리를 반드시 끝내야 한다.

enum DraftStore { static let shared = DraftStoreImpl() }
struct DraftStoreImpl { func saveAll() {} }
enum CoreDataStack { static let shared = CoreDataStackImpl() }
struct CoreDataStackImpl { func saveIfNeeded() throws {} }
enum Database { static let shared = DatabaseImpl() }
struct DatabaseImpl { func closeConnections() {}; func reopen() {} }
enum ImageCache { static let shared = ImageCacheImpl() }
struct ImageCacheImpl { func purgeMemory() {} }

import UIKit

// 작성 중인 글, 입력하던 폼, 그리던 그림은 '데이터'다.
// 비우기 전에 반드시 draft로 저장해야 한다.

@MainActor
final class ComposeViewModel: ObservableObject {
    @Published var text: String = "" {
        didSet { scheduleAutosave() }
    }
    @Published var attachments: [Attachment] = []

    private var autosaveTask: Task<Void, Never>?
    private let store: DraftStore

    init(store: DraftStore) {
        self.store = store

        // ✅ 백그라운드 진입 시 즉시 저장 (디바운스를 기다리지 않는다)
        NotificationCenter.default.addObserver(
            forName: UIApplication.didEnterBackgroundNotification,
            object: nil, queue: .main) { [weak self] _ in
            self?.saveNow()
        }
    }

    /// 입력 중에는 디바운스로 저장 — 매 타자마다 쓰지 않는다
    private func scheduleAutosave() {
        autosaveTask?.cancel()
        autosaveTask = Task {
            try? await Task.sleep(for: .seconds(2))
            guard !Task.isCancelled else { return }
            saveNow()
        }
    }

    private func saveNow() {
        autosaveTask?.cancel()
        try? store.save(Draft(text: text, attachments: attachments))
    }

    /// 복구 — 앱을 다시 켰을 때
    func restore() {
        guard let draft = try? store.load() else { return }
        text = draft.text
        attachments = draft.attachments
    }
}

// ⚠️ 판별 질문: "이걸 잃으면 사용자가 다시 만들어야 하는가?"
//    그렇다면 캐시가 아니라 데이터다. 영속 저장소로 간다.

struct Draft: Codable { let text: String; let attachments: [Attachment] }
struct Attachment: Codable {}
struct DraftStore {
    func save(_ d: Draft) throws {}
    func load() throws -> Draft? { nil }
}

import UIKit

// NSCache만 시스템이 자동으로 비워 준다.
// 직접 만든 딕셔너리·배열 캐시는 알림을 구독하지 않으면 절대 안 비워진다.

// ❌ 자동으로 비워질 거라 기대하는 코드
final class BadLayoutCache {
    private var heights: [String: CGFloat] = [:]
    // 메모리 경고가 와도 그대로 남는다 → jetsam의 밥
}

// ✅ 구독을 타입 안에 넣어 빠뜨릴 수 없게 만든다
class PurgeableCache<Key: Hashable, Value> {
    private var storage: [Key: Value] = [:]
    private var observer: NSObjectProtocol?

    init() {
        observer = NotificationCenter.default.addObserver(
            forName: UIApplication.didReceiveMemoryWarningNotification,
            object: nil, queue: .main
        ) { [weak self] _ in
            self?.purge()
        }
    }

    deinit {
        if let observer { NotificationCenter.default.removeObserver(observer) }
    }

    subscript(key: Key) -> Value? {
        get { storage[key] }
        set { storage[key] = newValue }
    }

    func purge() { storage.removeAll() }
    var count: Int { storage.count }
}

// 사용 — 이제 빠뜨릴 수가 없다
let layoutCache = PurgeableCache<String, CGFloat>()
let parseCache = PurgeableCache<String, [String]>()

// ✅ 커널 압박 신호까지 구독하면 UIKit 경고보다 이른 단계에서 대응할 수 있다
final class PressureAwareCache {
    private var storage: [String: Data] = [:]
    private var source: DispatchSourceMemoryPressure?

    init() {
        let s = DispatchSource.makeMemoryPressureSource(
            eventMask: [.warning, .critical], queue: .main)
        s.setEventHandler { [weak self] in
            guard let self, let data = self.source?.data else { return }
            if data.contains(.critical) { self.storage.removeAll() }
            else if data.contains(.warning) { self.trimHalf() }
        }
        s.resume()
        source = s                    // ⚠️ 강참조 보관 필수
    }

    private func trimHalf() {
        let keys = Array(storage.keys.prefix(storage.count / 2))
        keys.forEach { storage[$0] = nil }
    }
}