Day 10 · 1부 · 트리 기반 내비게이션 — @Presents와 ifLet

import SwiftUI
import Observation

struct Contact: Identifiable, Equatable, Hashable {
    let id: UUID
    var name: String
}

@Observable
final class AddContactModel: Identifiable {
    let id = UUID()
    var contact: Contact
    init(contact: Contact) { self.contact = contact }
}

@Observable
final class ContactsModel {
    var contacts: [Contact] = []
    var addContact: AddContactModel?          // nil이면 시트 닫힘

    func addButtonTapped() {
        addContact = AddContactModel(contact: Contact(id: UUID(), name: ""))
    }
    func saveButtonTapped() {
        guard let draft = addContact?.contact else { return }
        contacts.append(draft)
        addContact = nil                      // 닫기 = nil 대입
    }
}

struct ContactsScreen: View {
    @Bindable var model: ContactsModel

    var body: some View {
        List(model.contacts) { Text($0.name) }
            .toolbar { Button("추가") { model.addButtonTapped() } }
            .sheet(item: $model.addContact) { addModel in
                @Bindable var addModel = addModel
                Form { TextField("이름", text: $addModel.contact.name) }
                    .toolbar { Button("저장") { model.saveButtonTapped() } }
            }
    }
}

@Reducer
struct AddContactFeature {
  @ObservableState
  struct State: Equatable {
    var contact: Contact
  }
  enum Action {
    case cancelButtonTapped
    case saveButtonTapped
    case setName(String)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .cancelButtonTapped, .saveButtonTapped:
        return .none            // 자식은 아무것도 안 한다 — 부모가 이 액션을 듣는다
      case let .setName(name):
        state.contact.name = name
        return .none
      }
    }
  }
}

@Reducer
struct ContactsFeature {
  @ObservableState
  struct State: Equatable {
    @Presents var addContact: AddContactFeature.State?        // ① nil = 닫힘
    var contacts: IdentifiedArrayOf<Contact> = []
  }
  enum Action {
    case addButtonTapped
    case addContact(PresentationAction<AddContactFeature.Action>)  // ②
  }
  @Dependency(\.uuid) var uuid

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        // 값을 넣는 것 자체가 "시트를 띄워라"
        state.addContact = AddContactFeature.State(contact: Contact(id: uuid(), name: ""))
        return .none

      case .addContact(.presented(.cancelButtonTapped)):
        state.addContact = nil                                    // 닫기
        return .none

      case .addContact(.presented(.saveButtonTapped)):
        guard let contact = state.addContact?.contact else { return .none }
        state.contacts.append(contact)
        state.addContact = nil
        return .none

      case .addContact:
        return .none
      }
    }
    .ifLet(\.$addContact, action: \.addContact) {                 // ③
      AddContactFeature()
    }
  }
}

var body: some ReducerOf<Self> {
  Reduce { state, action in
    // ... 위와 같은 switch
  }
  // .ifLet(\.$addContact, action: \.addContact) { AddContactFeature() }  ← 빠짐
}

struct AddContactView: View {
  @Bindable var store: StoreOf<AddContactFeature>

  var body: some View {
    Form {
      TextField("이름", text: $store.contact.name.sending(\.setName))
      Button("저장") { store.send(.saveButtonTapped) }
    }
    .toolbar {
      Button("취소") { store.send(.cancelButtonTapped) }
    }
  }
}

struct ContactsView: View {
  @Bindable var store: StoreOf<ContactsFeature>

  var body: some View {
    NavigationStack {
      List(store.contacts) { contact in
        Text(contact.name)
      }
      .navigationTitle("연락처")
      .toolbar {
        Button("추가") { store.send(.addButtonTapped) }
      }
    }
    .sheet(item: $store.scope(\.addContact, action: \.addContact)) { addStore in
      NavigationStack {
        AddContactView(store: addStore)    // StoreOf<AddContactFeature>가 들어온다
      }
    }
  }
}

struct ContactsPushView: View {
  @Bindable var store: StoreOf<ContactsFeature>

  var body: some View {
    NavigationStack {
      List(store.contacts) { Text($0.name) }
        .toolbar { Button("추가") { store.send(.addButtonTapped) } }
        .navigationDestination(
          item: $store.scope(\.addContact, action: \.addContact)
        ) { addStore in
          AddContactView(store: addStore)
        }
    }
  }
}

#Preview("추가 시트가 열린 상태") {
  ContactsView(
    store: Store(
      initialState: ContactsFeature.State(
        addContact: AddContactFeature.State(       // 이 값이 있으면 시트가 떠 있다
          contact: Contact(id: UUID(), name: "민지")
        )
      )
    ) {
      ContactsFeature()
    }
  )
}

@Reducer
struct AddContactFeature {
  @ObservableState
  struct State: Equatable { var contact: Contact }
  enum Action {
    case cancelButtonTapped
    case delegate(Delegate)
    case saveButtonTapped
    case setName(String)
    @CasePathable   // 테스트에서 \.addContact.delegate.saveContact 경로를 쓰려면 필요
    enum Delegate: Equatable { case saveContact(Contact) }
  }
  @Dependency(\.dismiss) var dismiss

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .cancelButtonTapped:
        return .run { _ in await self.dismiss() }         // 부모 코드 없이 닫힌다
      case .delegate:
        return .none                                       // 부모만 듣는다
      case .saveButtonTapped:
        return .run { [contact = state.contact] send in
          await send(.delegate(.saveContact(contact)))     // 먼저 알리고
          await self.dismiss()                             // 마지막에 닫는다
        }
      case let .setName(name):
        state.contact.name = name
        return .none
      }
    }
  }
}

@Reducer
struct ContactsFeature {
  @ObservableState
  struct State: Equatable {
    @Presents var addContact: AddContactFeature.State?
    var contacts: IdentifiedArrayOf<Contact> = []
  }
  enum Action {
    case addButtonTapped
    case addContact(PresentationAction<AddContactFeature.Action>)
  }
  @Dependency(\.uuid) var uuid

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        state.addContact = AddContactFeature.State(contact: Contact(id: uuid(), name: ""))
        return .none
      case let .addContact(.presented(.delegate(.saveContact(contact)))):
        state.contacts.append(contact)                     // nil 대입이 사라졌다
        return .none
      case .addContact:
        return .none
      }
    }
    .ifLet(\.$addContact, action: \.addContact) { AddContactFeature() }
  }
}

case .saveButtonTapped:
  return .run { [contact = state.contact] send in
    await self.dismiss()
    await send(.delegate(.saveContact(contact)))   // ⚠️ 자식 상태는 이미 nil
  }

struct AddContactScreen: View {
  @Environment(\.dismiss) private var dismiss

  var body: some View {
    Button("취소") { dismiss() }     // 검증·비동기 작업을 끼우기 어렵다
  }
}

@MainActor
func saveFlowPrediction() async {
  let store = TestStore(
    initialState: ContactsFeature.State(
      addContact: AddContactFeature.State(contact: Contact(id: UUID(0), name: "민지"))
    )
  ) {
    ContactsFeature()
  }
  await store.send(\.addContact.saveButtonTapped)
  // { $0.??? } 와 receive(...) 를 채워 보자
}