Day 11 · 1부 · 스택 기반 내비게이션 — StackState와 NavigationStack

import SwiftUI
import Observation

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

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

struct MoviesRoot: View {
    @Bindable var router: MoviesRouter
    let movies: [Movie]

    var body: some View {
        NavigationStack(path: $router.path) {
            List(movies) { movie in
                NavigationLink(movie.title, value: MoviesRouter.Route.movie(movie))
            }
            .navigationDestination(for: MoviesRouter.Route.self) { route in
                switch route {
                case .movie(let movie):   Text(movie.title)   // 이 화면의 로직(모델)은 따로 만들어 연결해야 한다
                case .person(let person): Text(person.name)
                }
            }
        }
    }
}

@Reducer
struct MovieFeature {
  @ObservableState
  struct State: Equatable {
    let movie: Movie
    var cast: [Person] = [Person(id: 1, name: "배우 A"), Person(id: 2, name: "배우 B")]
  }
  enum Action {
    case personTapped(Person)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .personTapped:
        return .none            // push하지 않는다 — 루트가 듣고 path에 추가한다
      }
    }
  }
}

@Reducer
struct PersonFeature {
  @ObservableState
  struct State: Equatable {
    let person: Person
    var filmography: [Movie] = [Movie(id: 10, title: "영화 X"), Movie(id: 11, title: "영화 Y")]
  }
  enum Action {
    case movieTapped(Movie)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .movieTapped:
        return .none
      }
    }
  }
}

@Reducer
struct MoviesFeature {
  @Reducer
  enum Path {                                          // ① 스택에 올라갈 수 있는 화면들
    case movie(MovieFeature)
    case person(PersonFeature)
  }

  @ObservableState
  struct State: Equatable {
    var movies: [Movie] = [Movie(id: 1, title: "인셉션"), Movie(id: 2, title: "인터스텔라")]
    var path = StackState<Path.State>()                // ② 빈 배열 = 루트 화면만
  }
  enum Action {
    case path(StackActionOf<Path>)                     // ③ push · popFrom · element
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .path(.element(id: _, action: .movie(.personTapped(person)))):
        state.path.append(.person(PersonFeature.State(person: person)))   // push
        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
      }
    }
    .forEach(\.path, action: \.path)                   // ④ 클로저 생략 가능(enum Path)
  }
}
extension MoviesFeature.Path.State: Equatable {
  // 부모 State가 Equatable이면 필요하다.
  // 각 칸(MovieFeature.State · PersonFeature.State)과 그 안의 Movie · Person 값이 모두 Equatable이다.
}

// MoviesFeature 안
  @ObservableState
  struct State: Equatable {                  // 🛑 path가 Equatable이 아니라서 합성 실패
    var path = StackState<Path.State>()
  }
// extension MoviesFeature.Path.State: Equatable {}  ← 빠짐

struct MovieView: View {
  let store: StoreOf<MovieFeature>
  var body: some View {
    List(store.cast) { person in
      Button(person.name) { store.send(.personTapped(person)) }
    }
    .navigationTitle(store.movie.title)
  }
}

struct PersonView: View {
  let store: StoreOf<PersonFeature>
  var body: some View {
    List(store.filmography) { movie in
      Button(movie.title) { store.send(.movieTapped(movie)) }
    }
    .navigationTitle(store.person.name)
  }
}

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

  var body: some View {
    NavigationStack(path: $store.scope(\.path, action: \.path)) {
      // 루트: 항상 바닥에 있다
      List(store.movies) { movie in
        NavigationLink(
          movie.title,
          state: MoviesFeature.Path.State.movie(MovieFeature.State(movie: movie))
        )
      }
      .navigationTitle("영화")
    } destination: { store in
      // 칸마다: Path.State의 케이스로 분기
      switch store.case {
      case let .movie(store):
        MovieView(store: store)
      case let .person(store):
        PersonView(store: store)
      }
    }
  }
}

#Preview {
  MoviesView(store: Store(initialState: MoviesFeature.State()) { MoviesFeature() })
}

// MovieView 안
NavigationLink("배우 A", state: PersonFeature.State(person: Person(id: 1, name: "배우 A")))
// 스택 요소 타입은 MoviesFeature.Path.State인데 PersonFeature.State를 넘겼다

import Testing

@MainActor
@Test
func pushPrediction() async {
  let store = TestStore(
    initialState: MoviesFeature.State(
      path: StackState([.movie(MovieFeature.State(movie: Movie(id: 1, title: "인셉션")))])
    )
  ) {
    MoviesFeature()
  }
  store.exhaustivity = .off
  await store.send(\.path[id: 0].movie.personTapped, Person(id: 1, name: "배우 A"))
  #expect(store.state.path.count == 2)
}