Day 10 · 2부 · Destination enum·AlertState·트리 테스트

// ContactsFeature 안
  @ObservableState
  struct State {
    @Presents var addContact: AddContactFeature.State?
    @Presents var detail: ContactDetailFeature.State?
    @Presents var alert: AlertState<Action.Alert>?
  }

import SwiftUI
import Observation

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

@Observable
final class ContactsModel {
    enum Destination {
        case add(Contact)
        case confirmDelete(Contact)
    }
    var contacts: [Contact] = []
    var destination: Destination?
}

struct ContactsScreen: View {
    @Bindable var model: ContactsModel

    private var addBinding: Binding<Contact?> {
        Binding(
            get: { if case .add(let c) = model.destination { c } else { nil } },
            set: { if $0 == nil { model.destination = nil } }
        )
    }
    private var deleteAlertShown: Binding<Bool> {
        Binding(
            get: { if case .confirmDelete = model.destination { true } else { false } },
            set: { if !$0 { model.destination = nil } }
        )
    }

    var body: some View {
        List(model.contacts) { Text($0.name) }
            .sheet(item: addBinding) { contact in Text("\(contact.name) 추가") }
            .alert("삭제할까요?", isPresented: deleteAlertShown) {
                Button("삭제", role: .destructive) { /* 어떤 연락처였는지 다시 꺼내야 한다 */ }
            }
    }
}

@Reducer
struct AddContactFeature {
  @ObservableState
  struct State: Equatable { var contact: Contact }
  enum Action {
    case cancelButtonTapped
    case delegate(Delegate)
    case saveButtonTapped
    case setName(String)
    @CasePathable
    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
      }
    }
  }
}

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) } }
  }
}

@Reducer
struct ContactsFeature {
  @Reducer
  enum Destination {
    case addContact(AddContactFeature)                        // 리듀서가 있는 목적지
    case alert(AlertState<ContactsFeature.Action.Alert>)      // 데이터뿐인 목적지
  }

  @ObservableState
  struct State: Equatable {
    var contacts: IdentifiedArrayOf<Contact> = []
    @Presents var destination: Destination.State?             // 옵셔널은 이거 하나
  }
  enum Action {
    case addButtonTapped
    case deleteButtonTapped(id: Contact.ID)
    case destination(PresentationAction<Destination.Action>)
    @CasePathable
    enum Alert: Equatable { case confirmDeletion(id: Contact.ID) }
  }
  @Dependency(\.uuid) var uuid

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        state.destination = .addContact(AddContactFeature.State(contact: Contact(id: uuid(), name: "")))
        return .none

      case let .deleteButtonTapped(id):
        state.destination = .alert(Self.deleteAlert(id: id))   // 헬퍼는 아래, 2절에서 설명
        return .none

      case let .destination(.presented(.addContact(.delegate(.saveContact(contact))))):
        state.contacts.append(contact)
        return .none

      case let .destination(.presented(.alert(.confirmDeletion(id)))):
        state.contacts.remove(id: id)
        return .none                                          // 알럿은 알아서 nil이 된다

      case .destination:
        return .none
      }
    }
    .ifLet(\.$destination, action: \.destination)             // 트레일링 클로저 불필요
  }

  // 알럿 값을 만드는 정적 헬퍼 — 리듀서와 테스트가 같은 값을 쓴다
  static func deleteAlert(id: Contact.ID) -> AlertState<Action.Alert> {
    AlertState {
      TextState("정말 삭제할까요?")
    } actions: {
      ButtonState(role: .destructive, action: .confirmDeletion(id: id)) {
        TextState("삭제")
      }
      ButtonState(role: .cancel) {
        TextState("취소")                                     // 액션 없는 버튼
      }
    } message: {
      TextState("삭제한 연락처는 되돌릴 수 없다.")
    }
  }
}
extension ContactsFeature.Destination.State: Equatable {
  // 매크로가 만든 타입에 프로토콜만 붙인다.
  // 케이스 값(AddContactFeature.State · AlertState), 그 안에 든 Contact 값까지 모두 Equatable이라 합성된다.
}

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

  var body: some View {
    NavigationStack {
      List {
        ForEach(store.contacts) { contact in
          HStack {
            Text(contact.name)
            Spacer()
            Button("삭제", role: .destructive) {
              store.send(.deleteButtonTapped(id: contact.id))
            }
          }
        }
      }
      .navigationTitle("연락처")
      .toolbar { Button("추가") { store.send(.addButtonTapped) } }
    }
    .sheet(item: $store.scope(\.destination, action: \.destination).addContact) { addStore in
      NavigationStack { AddContactView(store: addStore) }
    }
    .alert($store.scope(\.destination, action: \.destination).alert)
  }
}

struct DeleteButtonScreen: View {
    @State private var isConfirming = false
    let onDelete: () -> Void

    var body: some View {
        Button("삭제", role: .destructive) { isConfirming = true }
            .alert("정말 삭제할까요?", isPresented: $isConfirming) {
                Button("삭제", role: .destructive) { onDelete() }   // 테스트로 누를 수 없다
                Button("취소", role: .cancel) {}
            } message: {
                Text("삭제한 연락처는 되돌릴 수 없다.")
            }
    }
}

@Reducer
struct SortFeature {
  @ObservableState
  struct State: Equatable {
    @Presents var dialog: ConfirmationDialogState<Action.Dialog>?
    var ascending = true
  }
  enum Action {
    case dialog(PresentationAction<Dialog>)
    case sortButtonTapped
    @CasePathable
    enum Dialog: Equatable { case ascending, descending }
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .sortButtonTapped:
        state.dialog = ConfirmationDialogState {
          TextState("정렬")
        } actions: {
          ButtonState(action: .ascending) { TextState("이름 오름차순") }
          ButtonState(action: .descending) { TextState("이름 내림차순") }
          ButtonState(role: .cancel) { TextState("취소") }
        }
        return .none
      case .dialog(.presented(.ascending)):
        state.ascending = true
        return .none
      case .dialog(.presented(.descending)):
        state.ascending = false
        return .none
      case .dialog:
        return .none
      }
    }
    .ifLet(\.$dialog, action: \.dialog)
  }
}

struct SortButton: View {
  @Bindable var store: StoreOf<SortFeature>
  var body: some View {
    Button("정렬") { store.send(.sortButtonTapped) }
      .confirmationDialog($store.scope(\.dialog, action: \.dialog))
  }
}

import Testing

@MainActor
@Test
func addFlow() async {
  let store = TestStore(initialState: ContactsFeature.State()) {
    ContactsFeature()
  } withDependencies: {
    $0.uuid = .incrementing                      // UUID(0), UUID(1)… 예측 가능
  }

  await store.send(.addButtonTapped) {
    $0.destination = .addContact(
      AddContactFeature.State(contact: Contact(id: UUID(0), name: ""))
    )
  }
  // 목적지 → 케이스 → 자식 액션을 key path로 이어 보낸다
  await store.send(\.destination.addContact.setName, "민지") {
    $0.destination?.modify(\.addContact) { $0.contact.name = "민지" }
  }
  await store.send(\.destination.addContact.saveButtonTapped)
  await store.receive(\.destination.addContact.delegate.saveContact, Contact(id: UUID(0), name: "민지")) {
    $0.contacts = [Contact(id: UUID(0), name: "민지")]
  }
  await store.receive(\.destination.dismiss) {   // 자식의 dismiss()가 보낸 액션
    $0.destination = nil
  }
}

import Testing

@MainActor
@Test
func deleteContact() async {
  let store = TestStore(
    initialState: ContactsFeature.State(
      contacts: [Contact(id: UUID(0), name: "민지"), Contact(id: UUID(1), name: "준호")]
    )
  ) {
    ContactsFeature()
  }

  await store.send(.deleteButtonTapped(id: UUID(1))) {
    $0.destination = .alert(ContactsFeature.deleteAlert(id: UUID(1)))   // 헬퍼 재사용
  }
  await store.send(\.destination.alert.confirmDeletion, UUID(1)) {
    $0.contacts = [Contact(id: UUID(0), name: "민지")]
    $0.destination = nil          // 부모가 대입하지 않았지만 ifLet이 nil로 만들었다
  }
}

import Testing

@MainActor
@Test
func addFlowNonExhaustive() async {
  let store = TestStore(initialState: ContactsFeature.State()) {
    ContactsFeature()
  } withDependencies: {
    $0.uuid = .incrementing
  }
  store.exhaustivity = .off

  await store.send(.addButtonTapped)
  await store.send(\.destination.addContact.setName, "민지")
  await store.send(\.destination.addContact.saveButtonTapped)
  await store.skipReceivedActions()
  store.assert {
    $0.contacts = [Contact(id: UUID(0), name: "민지")]
    $0.destination = nil
  }
}

import Testing

@MainActor
@Test
func cancelAlertPrediction() async {
  let store = TestStore(
    initialState: ContactsFeature.State(
      contacts: [Contact(id: UUID(0), name: "민지")],
      destination: .alert(ContactsFeature.deleteAlert(id: UUID(0)))
    )
  ) {
    ContactsFeature()
  }
  // await store.send(???) { ??? }
  _ = store
}

@Reducer
struct NotesFeature {
  @ObservableState
  struct State: Equatable {
    var notes: [String] = ["장보기", "운동"]
  }
  enum Action {
    case clearAllButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .clearAllButtonTapped:
        return .none
      }
    }
  }
}