Day 4 · 2부 · lifetime과 explicit identity

struct Note: Identifiable {
    let id: UUID
    var text: String
}

struct NoteEditor: View {
    let note: Note
    @State private var draft: String

    init(note: Note) {
        self.note = note
        _draft = State(initialValue: note.text)   // identity가 새로 생길 때만 쓰인다
    }

    var body: some View { TextEditor(text: $draft) }
}

struct NotesScreen: View {
    let notes: [Note]
    @State private var selected: Note?

    var body: some View {
        VStack {
            if let selected {
                NoteEditor(note: selected)
                    .id(selected.id)      // 부모가 identity를 바꿔 준다 → draft 새로 시작
            }
            ForEach(notes) { note in
                Button(note.text) { selected = note }
            }
        }
    }
}

struct ChartCard: View {
    let values: [Double]
    var body: some View {
        ChartBody(values: values)
            .id(UUID())       // body가 돌 때마다 새 identity → 상태 소실 + 애니메이션 없음 + 비용
    }
}

struct ChartBody: View {
    let values: [Double]
    @State private var highlighted: Int?
    var body: some View {
        HStack {
            ForEach(values.indices, id: \.self) { i in
                Capsule().frame(width: 8, height: values[i])
                    .opacity(highlighted == i ? 1 : 0.5)
                    .onTapGesture { highlighted = i }
            }
        }
    }
}

struct LifeLogView: View {
    let label: String
    @State private var taps = 0

    var body: some View {
        Button("\(label) · 탭 \(taps)") { taps += 1 }
            .onAppear { print("onAppear", label) }
            .onDisappear { print("onDisappear", label) }
            .task {
                print("task 시작", label)
                try? await Task.sleep(for: .seconds(60))
                print("task 종료(취소 포함)", label)
            }
    }
}

struct LifeLogHost: View {
    @State private var redraws = 0
    @State private var version = 0

    var body: some View {
        VStack(spacing: 16) {
            LifeLogView(label: "v\(version)")
                .id(version)                          // version이 바뀔 때만 새 identity
            Button("부모 다시 그리기 (\(redraws))") { redraws += 1 }   // 로그 없음, taps 유지
            Button("id 바꾸기") { version += 1 }      // 옛 뷰 onDisappear + 새 뷰 onAppear(두 로그의 순서는 문서가 보장하지 않는다), taps = 0
        }
    }
}

#Preview { LifeLogHost() }

struct UserDetail: View {
    let userID: Int
    @State private var name = "불러오는 중…"
    @State private var isFavorite = false     // userID가 바뀌어도 유지된다

    var body: some View {
        VStack {
            Text(name)
            Toggle("즐겨찾기 보기", isOn: $isFavorite)
        }
        .task(id: userID) {                     // userID가 바뀌면 이전 작업 취소 후 재시작
            try? await Task.sleep(for: .milliseconds(300))
            name = "사용자 \(userID)"
        }
    }
}

// ① 계산 프로퍼티의 랜덤 id — 읽을 때마다 새 id → 데이터가 바뀔 때마다 전부 깜빡인다
struct Pet: Identifiable {
    var name: String
    var id: UUID { UUID() }
}

// ② 인덱스 id — 위치가 이름표 → 맨 앞에 삽입해도 "끝에 추가"로 애니메이션된다
struct PetList: View {
    @State private var pets = [Pet(name: "보리"), Pet(name: "콩이")]
    var body: some View {
        List {
            ForEach(pets.indices, id: \.self) { i in Text(pets[i].name) }
        }
    }
}

// ③ 이름 id — 같은 이름이 두 개면 하나가 안 보이거나 뒤섞인다
struct Treat {
    var name: String
    var expiry: Date
}
struct TreatJar: View {
    let treats: [Treat]
    var body: some View {
        List(treats, id: \.name) { Text($0.name) }
    }
}

struct Pet: Identifiable {
    let id = UUID()          // 저장 프로퍼티 — 한 번 정해지면 끝
    var name: String
}

struct Treat: Identifiable {
    let id: Int              // 서버의 serial number 같은 영속 id가 있으면 그걸 쓴다
    var name: String
    var expiry: Date
}

struct PetList: View {
    @State private var pets = [Pet(name: "보리"), Pet(name: "콩이")]
    var body: some View {
        List {
            ForEach(pets) { pet in Text(pet.name) }
            Button("맨 앞에 추가") {
                withAnimation { pets.insert(Pet(name: "새 친구"), at: 0) }
            }
        }
    }
}

enum Breed { case borderCollie, poodle, mixed }

struct Dog {
    var name: String
    var breed: Breed
    var sheepNearby = false
}

func breedView(for dog: Dog) -> AnyView {
    var result: AnyView
    if dog.breed == .borderCollie {
        if dog.sheepNearby {
            result = AnyView(HStack { Text("🐕 \(dog.name)"); Text("🐑") })
        } else {
            result = AnyView(Text("🐕 \(dog.name)"))
        }
    } else if dog.breed == .poodle {
        result = AnyView(Text("🐩 \(dog.name)").italic())
    } else {
        result = AnyView(Label(dog.name, systemImage: "pawprint"))
    }
    return result
}

@ViewBuilder
func breedView(for dog: Dog) -> some View {
    switch dog.breed {
    case .borderCollie:
        HStack {
            Text("🐕 \(dog.name)")
            if dog.sheepNearby { Text("🐑") }   // HStack을 분기하지 말고 안에서 분기
        }
    case .poodle:
        Text("🐩 \(dog.name)").italic()
    case .mixed:
        Label(dog.name, systemImage: "pawprint")
    }
}

struct TaskItem {
    var title: String
}

struct TaskRow: View {
    let title: String
    @State private var memo = ""
    var body: some View {
        VStack(alignment: .leading) {
            Text(title).font(.headline)
            TextField("메모", text: $memo)
        }
    }
}

struct TaskBoard: View {
    @State private var tasks = [TaskItem(title: "장보기"), TaskItem(title: "운동")]
    @State private var showDone = false

    var body: some View {
        List {
            Toggle("완료 표시", isOn: $showDone)
            ForEach(tasks.indices, id: \.self) { i in
                if showDone {
                    TaskRow(title: "✅ " + tasks[i].title)
                } else {
                    TaskRow(title: tasks[i].title)
                }
            }
            Button("맨 앞에 추가") {
                withAnimation { tasks.insert(TaskItem(title: "새 할 일 \(tasks.count)"), at: 0) }
            }
        }
    }
}

#Preview { TaskBoard() }