02 · 상태 — 단일 진실 공급원

struct ProfileEditor: View {
    let user: User                      // 진실 ①: 넘겨받은 원본
    @State private var name: String     // 진실 ②: 복사본

    init(user: User) {
        self.user = user
        _name = State(initialValue: user.name)   // 이 시점의 스냅샷
    }

    var body: some View {
        TextField("이름", text: $name)
        // 문제 1: 여기서 편집해도 user.name 은 안 바뀐다
        // 문제 2: 부모가 다른 user 를 넘겨줘도 name 은 그대로다
        //         → @State 기본값은 identity가 처음 만들어질 때만 쓰인다 (3챕터)
    }
}

@Observable final class User {          // 참조 타입 모델
    var name: String
    init(name: String) { self.name = name }
}

struct ProfileEditor: View {
    @Bindable var user: User            // 복사하지 않는다. 바인딩만 만든다

    var body: some View {
        TextField("이름", text: $user.name)   // 편집이 곧바로 모델에 반영된다
    }
}

@Observable final class Cart {                    // 참조 타입 모델
    var items: [Item] = []
    var couponCode: String = ""
    var total: Int { items.reduce(0) { $0 + $1.price } }
}

@main
struct ShopApp: App {
    @State private var cart = Cart()              // ① 소유: 진실은 여기 하나

    var body: some Scene {
        WindowGroup {
            CartScreen()
                .environment(cart)                // ② 계층에 흘려보낸다
        }
    }
}

struct CartScreen: View {
    @Environment(Cart.self) private var cart      // ③ 중간 뷰 없이 꺼내 쓴다
    @State private var showsCoupon = false        // ④ 값 타입 로컬 UI 상태

    var body: some View {
        VStack {
            Text("합계 \(cart.total)원")           // total 을 읽었으니 여기가 의존한다
            Button("쿠폰 입력") { showsCoupon = true }
        }
        .sheet(isPresented: $showsCoupon) {        // ⑤ Binding 으로 통로를 넘긴다
            CouponEditor(cart: cart)               //    모델은 참조라 그냥 넘긴다
        }
    }
}

struct CouponEditor: View {
    @Bindable var cart: Cart                       // ⑥ 모델 프로퍼티에 바인딩이 필요할 때

    var body: some View {
        TextField("쿠폰 코드", text: $cart.couponCode)
    }
}

struct PlayerView: View {
    @State private var isPlaying = false     // 여기가 진실. private 필수

    var body: some View {
        VStack {
            // 읽기만 → 값 그대로 넘긴다. Binding 불필요
            TitleLabel(isPlaying: isPlaying)

            // 쓰기도 해야 함 → $ 로 바인딩을 넘긴다
            PlayButton(isPlaying: $isPlaying)
        }
    }
}

struct ContentView: View {
    @State private var library = Library()   // 무거우면 이게 매번 비용
    var body: some View { LibraryView(library: library) }
}

struct ContentView: View {
    @State private var library: Library?

    var body: some View {
        LibraryView(library: library)
            .task { library = Library() }    // 최초 등장 시 한 번만
    }
}

@Observable class Book: Identifiable {
    var title = "Sample Book Title"
    var author = Author()
    var isAvailable = true
}

struct BookRow: View {
    var book: Book

    var body: some View {
        HStack {
            Text(book.title)                       // title 읽음
            AvailabilityChart(book.isAvailable)    // isAvailable 읽음 + 무거움
        }
        // title 만 바뀌어도 이 body 전체가 다시 돌고, 차트도 다시 만들어진다
    }
}

struct BookRow: View {
    var book: Book

    var body: some View {
        HStack {
            TitleText(book: book)          // 여기서는 아무 프로퍼티도 읽지 않는다
            AvailabilityBadge(book: book)  // → BookRow 는 의존성이 없다
        }
    }
}

private struct TitleText: View {
    var book: Book
    var body: some View { Text(book.title) }               // title 에만 의존
}

private struct AvailabilityBadge: View {
    var book: Book
    var body: some View { AvailabilityChart(book.isAvailable) }  // isAvailable 에만 의존
}

// 읽기 + 메서드 호출 → 래퍼 불필요
struct BookView: View {
    var book: Book
    var body: some View {
        Button(book.isAvailable ? "Check out" : "Return") {
            book.isAvailable.toggle()      // 바인딩 없이 그냥 바꿔도 된다
        }
    }
}

// TextField 처럼 Binding을 요구할 때만
struct BookEditView: View {
    @Bindable var book: Book
    var body: some View {
        TextField("Title", text: $book.title)
    }
}

@main
struct BookReaderApp: App {
    @State private var library = Library()      // 진실은 여기 하나

    var body: some Scene {
        WindowGroup {
            LibraryView().environment(library)  // 계층에 흘려보낸다
        }
    }
}

struct DeepChildView: View {
    @Environment(Library.self) private var library   // 중간 뷰를 안 거친다
    var body: some View { Text("\(library.availableBooksCount)권") }
}

final class Library: ObservableObject {
    @Published var books: [Book] = []
    @Published var searchText = ""
    var cacheDir: URL?                        // 관찰 대상이 아님을 표시할 방법이 없다
}

@main
struct BookReaderApp: App {
    @StateObject private var library = Library()
    var body: some Scene {
        WindowGroup {
            LibraryView().environmentObject(library)
        }
    }
}

struct BookCountLabel: View {
    @EnvironmentObject var library: Library
    var body: some View {
        Text("\(library.books.count)권")
        // ⚠️ searchText 를 읽지 않는데도, 타이핑할 때마다 이 뷰가 갱신된다
    }
}

@Observable final class Library {
    var books: [Book] = []
    var searchText = ""
    @ObservationIgnored var cacheDir: URL?    // 추적에서 명시적으로 제외
}

@main
struct BookReaderApp: App {
    @State private var library = Library()     // StateObject → State
    var body: some Scene {
        WindowGroup {
            LibraryView().environment(library) // environmentObject → environment
        }
    }
}

struct BookCountLabel: View {
    @Environment(Library.self) private var library
    var body: some View {
        Text("\(library.books.count)권")
        // ✅ books 만 읽었으니, searchText 타이핑에는 갱신되지 않는다
    }
}