01 · 값 타입과 참조 타입

class C { var v = 0 }
struct S { var age = 1 }

let c1 = C(); let c2 = c1
c2.v = 42
print("class: c1.v =", c1.v)              // 42 — 같은 인스턴스를 공유

var s1 = S(); var s2 = s1
s2.age = 99
print("struct: s1.age =", s1.age, "s2.age =", s2.age)  // 1 99 — 독립적

struct ProductViewModel {
    let id: String
    let title: String
    let priceText: String   // 이미 포매팅된 문자열 — 뷰가 그대로 표시
}

// 여러 셀에 값을 나눠줘도 원본 배열과는 독립적으로 복사되어 안전하다
func makeViewModels(from products: [Product]) -> [ProductViewModel] {
    products.map {
        ProductViewModel(id: $0.id, title: $0.title, priceText: "₩\($0.price)")
    }
}

final class ImageCache {
    static let shared = ImageCache()
    private var storage: [String: UIImage] = [:]

    func image(for key: String) -> UIImage? { storage[key] }
    func insert(_ image: UIImage, for key: String) { storage[key] = image }
}

// 어디서 shared를 받아도 항상 같은 캐시 인스턴스 — struct였다면 대입마다 복사돼 캐시가 갈라진다
let cacheRef = ImageCache.shared

var a = [1, 2, 3]
var b = a
a.withUnsafeBufferPointer { print("a:", $0.baseAddress!) }
b.withUnsafeBufferPointer { print("b:", $0.baseAddress!) }   // a와 같은 주소

b.append(4)
b.withUnsafeBufferPointer { print("b append 후:", $0.baseAddress!) }  // 주소가 바뀜
a.withUnsafeBufferPointer { print("a는 그대로:", $0.baseAddress!) }   // a는 원래 주소 그대로

final class Storage {
    var items: [String]
    init(_ items: [String]) { self.items = items }
    func copy() -> Storage { Storage(items) }
}

struct TagList {
    private var storage: Storage

    init(_ items: [String] = []) {
        storage = Storage(items)
    }

    var count: Int { storage.items.count }

    subscript(index: Int) -> String {
        // 읽기 전용 경로 — 유일성 검사도, 복제도 하지 않는다
        _read {
            yield storage.items[index]
        }
        // 쓰기 경로 — 여기서만 "나 혼자 쓰고 있나"를 확인한다
        _modify {
            if !isKnownUniquelyReferenced(&storage) {
                storage = storage.copy()   // 공유 중이면 그때 복제
            }
            yield &storage.items[index]
        }
    }

    mutating func append(_ tag: String) {
        if !isKnownUniquelyReferenced(&storage) {
            storage = storage.copy()
        }
        storage.items.append(tag)
    }
}

var a = TagList(["swift", "ios"])
var b = a                        // 버퍼 참조만 복사, refCount = 2
b.append("cow")                  // 공유 중이라 복제 → b만 새 버퍼로
print(a.count, b.count)          // 2 3 — a는 영향받지 않음

struct BuggyTagList {
    private var storage: Storage
    init(_ items: [String] = []) { storage = Storage(items) }
    var count: Int { storage.items.count }

    // ❌ isKnownUniquelyReferenced 체크가 빠졌다
    mutating func append(_ tag: String) {
        storage.items.append(tag)   // 공유 중이어도 그냥 기존 버퍼를 고쳐버린다
    }
}

var x = BuggyTagList(["a"])
var y = x
y.append("b")
print(x.count, y.count)   // 기대: 1 2 — 실제: 2 2, x도 같이 바뀌어버린다

struct Puppy {
    let age: Int         // 8바이트, alignment 8
    let isTrained: Bool  // 1바이트, alignment 1
}
print(MemoryLayout<Puppy>.size)       // 9  — 8 + 1
print(MemoryLayout<Puppy>.stride)     // 16 — size를 alignment(8)의 배수로 올림
print(MemoryLayout<Puppy>.alignment)  // 8  — 가장 큰 필드(Int)의 alignment를 물려받음

protocol P {}
struct Small: P { let a: Int8 }              // MemoryLayout<Small>.size == 1
struct Big: P { let a, b, c, d: Int64 }      // MemoryLayout<Big>.size == 32

let values: [P] = [Small(a: 1), Big(a: 1, b: 2, c: 3, d: 4)]
for v in values {
    print(MemoryLayout<P>.size)   // 둘 다 40 — existential container 크기(5워드)
}

struct Puppy { let age: Int; let isTrained: Bool }

func estimatedFootprint(count: Int) -> Int {
    // size(9)가 아니라 stride(16) 기준 — 배열 원소 사이 패딩까지 포함해야 실제 값이 나온다
    MemoryLayout<Puppy>.stride * count
}
print(estimatedFootprint(count: 100_000))  // 1,600,000 바이트 ≈ 1.53MB

func secondElementOffset<T>(of type: T.Type) -> Int {
    // size로 계산하면 패딩을 무시하게 되어 실제 두 번째 원소 위치와 어긋난다
    MemoryLayout<T>.stride
}
print(secondElementOffset(of: Puppy.self))  // 16

struct UserBadge {
    let isVerified: Bool   // 1B, align 1
    let level: Int16       // 2B, align 2
    let score: Int64       // 8B, align 8
    let tier: UInt8        // 1B, align 1
}
struct UserBadgeReordered {
    let score: Int64       // 8B, align 8 — 가장 큰 정렬 요구를 먼저
    let level: Int16       // 2B, align 2
    let tier: UInt8        // 1B, align 1
    let isVerified: Bool   // 1B, align 1
}

print(MemoryLayout<UserBadge>.size, MemoryLayout<UserBadge>.stride)                   // 17 24
print(MemoryLayout<UserBadgeReordered>.size, MemoryLayout<UserBadgeReordered>.stride)  // 12 16

let count = 100_000
let before = MemoryLayout<UserBadge>.stride * count           // 2,400,000B ≈ 2.29MB
let after  = MemoryLayout<UserBadgeReordered>.stride * count  // 1,600,000B ≈ 1.53MB
print("절약:", before - after, "바이트")                        // 800,000B ≈ 0.76MB

// ❌ 선언 순서가 뒤섞여 있으면 필드 사이사이에 패딩이 낀다
struct LogEntryBad {
    let isError: Bool       // 1B
    let timestamp: Int64    // 8B — 이 앞에 패딩 7B
    let level: UInt8        // 1B
    let sequence: Int32     // 4B — 이 앞에 패딩 3B
}

// ✅ 큰 정렬 요구 → 작은 정렬 요구 순서로 정리
struct LogEntryGood {
    let timestamp: Int64    // 8B
    let sequence: Int32     // 4B
    let level: UInt8        // 1B
    let isError: Bool       // 1B — tail 패딩만 최소로 남음
}

struct AllFlags {
    let a: Bool
    let b: Bool
    let c: Bool
    let d: Bool
}
struct AllFlagsReordered {
    let d: Bool
    let c: Bool
    let b: Bool
    let a: Bool
}
print(MemoryLayout<AllFlags>.size, MemoryLayout<AllFlags>.stride)                  // 4 4
print(MemoryLayout<AllFlagsReordered>.size, MemoryLayout<AllFlagsReordered>.stride) // 4 4 — 완전히 동일

actor SessionCache {
    private var tokens: [String: String] = [:]
    func store(_ token: String, for userID: String) { tokens[userID] = token }
    func token(for userID: String) -> String? { tokens[userID] }
}

func demo() async {
    let cache = SessionCache()
    let cache2 = cache                       // 참조 복사 — 같은 액터 인스턴스를 가리킴
    await cache.store("abc123", for: "u1")
    let t = await cache2.token(for: "u1")
    print(t ?? "nil")                        // "abc123" — cache와 cache2는 같은 상태를 본다
}

actor DownloadTracker {
    private var inFlight: Set<URL> = []

    func begin(_ url: URL) -> Bool {
        guard !inFlight.contains(url) else { return false }  // 이미 진행 중이면 중복 요청 방지
        inFlight.insert(url)
        return true
    }
    func finish(_ url: URL) { inFlight.remove(url) }
}

// ✅ 정체성 공유가 필요 없다 — 그냥 값 타입으로 충분
struct RequestBudget {
    private(set) var remaining: Int
    mutating func consume() { remaining -= 1 }
}

// ❌ 단순 값 컨테이너를 actor로 감싸면 호출부마다 await가 강제된다
actor RequestBudgetActor {
    private var remaining: Int
    init(_ remaining: Int) { self.remaining = remaining }
    func consume() { remaining -= 1 }
}

func demoOveruse() async {
    var budget = RequestBudget(remaining: 3)
    budget.consume()              // 동기 호출 — 가볍다

    let budgetActor = RequestBudgetActor(3)
    await budgetActor.consume()   // 공유할 대상이 없는데도 await가 강제된다
}

class BaseViewController: UIViewController {
    private let spinner = UIActivityIndicatorView(style: .medium)
    func showSpinner() { spinner.startAnimating() }
    func hideSpinner() { spinner.stopAnimating() }
    func showError(_ message: String) { /* 배너 표시 */ }
}

// SettingsVC는 스피너만 필요한데도 showError까지 함께 상속받는다
final class SettingsViewController: BaseViewController { /* ... */ }

protocol LoadingPresentable: AnyObject {
    var loadingIndicator: UIActivityIndicatorView { get }
}
extension LoadingPresentable where Self: UIViewController {
    func showSpinner() { loadingIndicator.startAnimating() }
    func hideSpinner() { loadingIndicator.stopAnimating() }
}

protocol ErrorPresentable: AnyObject {}
extension ErrorPresentable where Self: UIViewController {
    func showError(_ message: String) { /* 배너 표시 */ }
}

// ProfileVC는 두 능력 다 필요
final class ProfileViewController: UIViewController, LoadingPresentable, ErrorPresentable {
    let loadingIndicator = UIActivityIndicatorView(style: .medium)
}

// SettingsVC는 로딩만 필요 — ErrorPresentable을 강제로 물려받지 않는다
final class SettingsViewController: UIViewController, LoadingPresentable {
    let loadingIndicator = UIActivityIndicatorView(style: .medium)
}