Day 11 · 2부 · StackElementID·스택 조작·딥링크·테스트

// MoviesFeature의 Reduce 안
case let .path(.element(id: id, action: .movie(.favoriteButtonTapped))):
  let index = state.path.ids.firstIndex(of: id)!     // 지금은 2번째 칸
  return .run { send in
    try await clock.sleep(for: .seconds(1))
    await send(.favoriteSavedAt(index: index))       // 1초 뒤에도 2번째 칸일까?
  }

struct Movie: Identifiable, Equatable { let id: Int; var title: String }
struct Person: Identifiable, Equatable { let id: Int; var name: String }

@Reducer
struct MovieFeature {
  @ObservableState
  struct State: Equatable {
    let movie: Movie
    var isFavorite = false
  }
  enum Action {
    case favoriteButtonTapped
    case personTapped(Person)
  }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }                     // 두 액션 모두 루트가 처리한다
  }
}

@Reducer
struct PersonFeature {
  @ObservableState
  struct State: Equatable { let person: Person }
  enum Action {
    case closeButtonTapped
    case movieTapped(Movie)
  }
  @Dependency(\.dismiss) var dismiss
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .closeButtonTapped:
        return .run { _ in await self.dismiss() }  // → .path(.popFrom(id: 내 id))
      case .movieTapped:
        return .none
      }
    }
  }
}

struct MovieView: View {
  let store: StoreOf<MovieFeature>
  var body: some View {
    Button(store.isFavorite ? "★ 즐겨찾기됨" : "☆ 즐겨찾기") { store.send(.favoriteButtonTapped) }
      .navigationTitle(store.movie.title)
  }
}

struct PersonView: View {
  let store: StoreOf<PersonFeature>
  var body: some View {
    Button("닫기") { store.send(.closeButtonTapped) }
      .navigationTitle(store.person.name)
  }
}

@Reducer
struct MoviesFeature {
  @Reducer
  enum Path {
    case movie(MovieFeature)
    case person(PersonFeature)
  }
  @ObservableState
  struct State: Equatable {
    var path = StackState<Path.State>()
  }
  enum Action {
    case favoriteSaved(id: StackElementID)
    case goBack(to: StackElementID)
    case openURL(URL)
    case path(StackActionOf<Path>)
    case popToRootButtonTapped
  }
  @Dependency(\.continuousClock) var clock

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .favoriteSaved(id):
        state.path[id: id]?.modify(\.movie) { $0.isFavorite = true }  // 칸이 없으면 아무 일 없음
        return .none

      case let .goBack(id):
        state.path.pop(to: id)                   // 그 칸은 남기고 위쪽만 내린다
        return .none

      case let .openURL(url):
        guard let path = Self.path(for: url) else { return .none }
        state.path = path                        // 딥링크 = 배열을 통째로 바꾸기
        return .none

      case let .path(.element(id: id, action: .movie(.favoriteButtonTapped))):
        return .run { send in
          try await clock.sleep(for: .seconds(1))  // 서버 저장이라고 치자
          await send(.favoriteSaved(id: id))       // 인덱스가 아니라 id를 돌려준다
        }

      case let .path(.element(id: _, action: .movie(.personTapped(person)))):
        state.path.append(.person(PersonFeature.State(person: person)))
        return .none

      case let .path(.element(id: _, action: .person(.movieTapped(movie)))):
        state.path.append(.movie(MovieFeature.State(movie: movie)))
        return .none

      case .path:
        return .none

      case .popToRootButtonTapped:
        state.path.removeAll()
        return .none
      }
    }
    .forEach(\.path, action: \.path)
  }

  // "movies://movie/1/person/7" → [.movie(1), .person(7)]
  static func path(for url: URL) -> StackState<Path.State>? {
    guard url.scheme == "movies", let host = url.host() else { return nil }
    let parts = [host] + url.pathComponents.dropFirst()
    var path = StackState<Path.State>()
    var i = 0
    while i + 1 < parts.count, let id = Int(parts[i + 1]) {
      switch parts[i] {
      case "movie":  path.append(.movie(MovieFeature.State(movie: Movie(id: id, title: "영화 \(id)"))))
      case "person": path.append(.person(PersonFeature.State(person: Person(id: id, name: "배우 \(id)"))))
      default:       return nil
      }
      i += 2
    }
    return path
  }
}
extension MoviesFeature.Path.State: Equatable {
  // 칸(MovieFeature.State · PersonFeature.State)과 그 안의 Movie · Person 값이 Equatable이다.
}

import SwiftUI
import Observation

@Observable
final class MoviesRouter {
    enum Route: Hashable { case movie(id: Int), person(id: Int) }
    var path: [Route] = []

    func popToRoot() { path.removeAll() }
    func goBack(toIndex index: Int) { path.removeSubrange((index + 1)...) }  // 인덱스가 바뀌면 틀린다
    func open(_ url: URL) { path = [.movie(id: 1), .person(id: 7)] }       // 파싱은 생략
}

struct MoviesView: View {
  @Bindable var store: StoreOf<MoviesFeature>

  var body: some View {
    NavigationStack(path: $store.scope(\.path, action: \.path)) {
      Button("영화 1 열기") { store.send(.openURL(URL(string: "movies://movie/1")!)) }
    } destination: { store in
      switch store.case {
      case let .movie(store):  MovieView(store: store)
      case let .person(store): PersonView(store: store)
      }
    }
    .safeAreaInset(edge: .bottom) {
      Menu("현재 스택") {
        ForEach(Array(zip(store.path.ids, store.path)), id: \.0) { id, element in
          Button(Self.title(of: element)) { store.send(.goBack(to: id)) }
        }
        Button("루트로") { store.send(.popToRootButtonTapped) }
      }
    }
    .onOpenURL { store.send(.openURL($0)) }      // 딥링크도 결국 액션 하나
  }

  static func title(of element: MoviesFeature.Path.State) -> String {
    switch element {
    case let .movie(state):  state.movie.title
    case let .person(state): state.person.name
    }
  }
}

import Testing

@MainActor
@Test
func favorite() async {
  let clock = TestClock()
  let store = TestStore(initialState: MoviesFeature.State()) {
    MoviesFeature()
  } withDependencies: {
    $0.continuousClock = clock
  }
  let inception = MovieFeature.State(movie: Movie(id: 1, title: "인셉션"))

  // NavigationLink(state:) 탭을 흉내 낸다 — push 액션
  await store.send(\.path.push, (id: 0, .movie(inception))) {
    $0.path[id: 0] = .movie(inception)
  }
  await store.send(\.path[id: 0].movie.favoriteButtonTapped)
  await clock.advance(by: .seconds(1))
  await store.receive(\.favoriteSaved) {
    $0.path[id: 0, case: \.movie]?.isFavorite = true     // id + 케이스로 한 번에
  }
}

import Testing

@MainActor
@Test
func personClosesItself() async {
  let store = TestStore(
    initialState: MoviesFeature.State(
      path: StackState([
        .movie(MovieFeature.State(movie: Movie(id: 1, title: "인셉션"))),   // id 0
        .person(PersonFeature.State(person: Person(id: 7, name: "배우 7"))), // id 1
      ])
    )
  ) {
    MoviesFeature()
  }
  await store.send(\.path[id: 1].person.closeButtonTapped)
  await store.receive(\.path.popFrom) {                   // dismiss()가 보낸 액션
    $0.path[id: 1] = nil
  }
}

@MainActor
@Test
func deepLink() async {
  let store = TestStore(initialState: MoviesFeature.State()) {
    MoviesFeature()
  }
  await store.send(.openURL(URL(string: "movies://movie/1/person/7")!)) {
    $0.path = StackState([
      .movie(MovieFeature.State(movie: Movie(id: 1, title: "영화 1"))),
      .person(PersonFeature.State(person: Person(id: 7, name: "배우 7"))),
    ])
  }
}

import Testing

@MainActor
@Test
func favoriteRacePrediction() async {
  let clock = TestClock()
  let store = TestStore(
    initialState: MoviesFeature.State(
      path: StackState([.movie(MovieFeature.State(movie: Movie(id: 1, title: "인셉션")))])
    )
  ) {
    MoviesFeature()
  } withDependencies: {
    $0.continuousClock = clock
  }
  store.exhaustivity = .off
  await store.send(\.path[id: 0].movie.favoriteButtonTapped)
  await store.send(\.path.popFrom, 0)            // 저장 전에 뒤로
  await clock.advance(by: .seconds(1))
}

@Reducer
struct StepFeature {
  @ObservableState
  struct State: Equatable { var number: Int }
  enum Action {
    case nextButtonTapped
    case restartButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }        // 루트가 듣는다
  }
}