Day 14 · 1부 · 실전 구조 — 앱 지도·모듈화·UIKit

// SyncUps의 자식 기능들 — 여기서는 골격만 남겼다 (원본: Examples/SyncUps)
@Reducer
struct SyncUpsList {
  @ObservableState
  struct State: Equatable { var titles: [String] = [] }
  enum Action { case addSyncUpButtonTapped }
  var body: some ReducerOf<Self> { Reduce { _, _ in .none } }
}

@Reducer
struct SyncUpDetail {
  @ObservableState
  struct State: Equatable { var title = "" }
  enum Action {
    case delegate(Delegate)
    case startMeetingButtonTapped
    @CasePathable
    enum Delegate { case startMeeting(title: String) }   // 원본은 Shared<SyncUp>을 넘긴다
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .delegate:
        return .none
      case .startMeetingButtonTapped:
        return .send(.delegate(.startMeeting(title: state.title)))  // "부모야, 회의 시작해 줘"
      }
    }
  }
}

@Reducer
struct RecordMeeting {
  @ObservableState
  struct State: Equatable { var title: String }
  enum Action { case endMeetingButtonTapped }
  var body: some ReducerOf<Self> { Reduce { _, _ in .none } }
}

@Reducer
struct AppFeature {
  @Reducer(state: .equatable)          // TestStore로 테스트하려면 State가 Equatable이어야 한다
  enum Path {                          // push될 수 있는 화면 목록 (Day 11)
    case detail(SyncUpDetail)
    case record(RecordMeeting)
  }

  @ObservableState
  struct State: Equatable {
    var path = StackState<Path.State>()
    var syncUpsList = SyncUpsList.State()   // 루트 화면은 항상 존재
  }

  enum Action {
    case path(StackActionOf<Path>)
    case syncUpsList(SyncUpsList.Action)
  }

  var body: some ReducerOf<Self> {
    Scope(\.syncUpsList, action: \.syncUpsList) {   // Day 5
      SyncUpsList()
    }
    Reduce { state, action in
      switch action {
      // 상세 화면의 delegate 액션을 가로채 기록 화면을 push
      case let .path(.element(_, .detail(.delegate(.startMeeting(title))))):
        state.path.append(.record(RecordMeeting.State(title: title)))
        return .none
      case .path, .syncUpsList:
        return .none
      }
    }
    .forEach(\.path, action: \.path)       // 스택의 각 화면에 자식 리듀서 연결
  }
}

struct AppView: View {
  @Bindable var store: StoreOf<AppFeature>

  var body: some View {
    NavigationStack(path: $store.scope(\.path, action: \.path)) {
      Text("SyncUps 목록")                 // 원본: SyncUpsListView(store: …)
    } destination: { store in
      switch store.case {
      case let .detail(store): Text(store.title)
      case let .record(store): Text("회의 중: \(store.title)")
      }
    }
  }
}

@main
struct SyncUpsApp: App {
  // 앱 전체에 스토어는 하나. static으로 둬서 Preview가 앱 진입점을 다시 만들 때 섞이지 않게 한다
  static let store = Store(initialState: AppFeature.State()) {
    AppFeature()
      ._printChanges()                     // 모든 액션과 상태 diff를 콘솔에
  }

  var body: some Scene {
    WindowGroup {
      if isTesting {
        EmptyView()                        // 테스트 중엔 앱 코드를 띄우지 않는다
      } else {
        AppView(store: Self.store)
      }
    }
  }
}

// ── Module: AuthenticationClient (인터페이스) ──
@DependencyClient
public struct AuthenticationClient: Sendable {
  public var login: @Sendable (_ email: String, _ password: String) async throws -> String
}

extension AuthenticationClient: TestDependencyKey {
  public static let testValue = Self()     // 테스트에서 안 덮어쓰고 부르면 실패
}

extension DependencyValues {
  public var authenticationClient: AuthenticationClient {
    get { self[AuthenticationClient.self] }
    set { self[AuthenticationClient.self] = newValue }
  }
}

// ── Module: AuthenticationClientLive (실제 구현) ──
extension AuthenticationClient: DependencyKey {
  public static let liveValue = Self(
    login: { email, password in
      try await Task.sleep(for: .seconds(1))  // 실제로는 네트워크·서드파티 SDK
      return "token-for-\(email)"
    }
  )
}

// ── Module: LoginCore ── 다른 모듈에서 쓰려면 타입·init·body가 public
@Reducer
public struct Login {
  @ObservableState
  public struct State: Equatable {
    public var email = ""
    public var isLoading = false
    public init(email: String = "") { self.email = email }
  }

  public enum Action {
    case loginButtonTapped
    case loginResponse(Result<String, any Error>)
  }

  @Dependency(\.authenticationClient) var authenticationClient   // 인터페이스만 안다

  public init() {}

  public var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .loginButtonTapped:
        state.isLoading = true
        return .run { [email = state.email] send in
          await send(.loginResponse(Result {
            try await authenticationClient.login(email: email, password: "password")
          }))
        }
      case .loginResponse:
        state.isLoading = false
        return .none
      }
    }
  }
}

@Reducer
struct Counter {
  @ObservableState
  struct State: Equatable { var count = 0 }
  enum Action { case incrementButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

final class CounterViewController: UIViewController {
  private let store: StoreOf<Counter>

  init(store: StoreOf<Counter>) {
    self.store = store
    super.init(nibName: nil, bundle: nil)
  }
  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }

  override func viewDidLoad() {
    super.viewDidLoad()
    let countLabel = UILabel()
    let incrementButton = UIButton(type: .system, primaryAction: UIAction { [weak self] _ in
      self?.store.send(.incrementButtonTapped)       // 입력: 액션을 보낸다
    })
    incrementButton.setTitle("+", for: .normal)
    view.addSubview(UIStackView(arrangedSubviews: [countLabel, incrementButton]))

    observe { [weak self] in                         // 출력: 읽은 상태가 바뀌면 다시 실행
      guard let self else { return }
      countLabel.text = "\(store.count)"
    }
  }
}

// 1.7 이전 UIKit 관찰 — Combine 구독을 필드마다 손으로 관리했다
private var cancellables: Set<AnyCancellable> = []

override func viewDidLoad() {
  super.viewDidLoad()
  store.publisher.count
    .sink { [weak self] in self?.countLabel.text = "\($0)" }
    .store(in: &cancellables)
}

@Reducer
struct CodeEntry {
  @ObservableState
  struct State: Equatable {
    @Presents var alert: AlertState<Action.Alert>?
    var code = ""
    var isRequestInFlight = false
  }
  enum Action: BindableAction {
    case alert(PresentationAction<Alert>)
    case binding(BindingAction<State>)
    case submitButtonTapped
    enum Alert: Equatable {}
  }
  var body: some ReducerOf<Self> {
    BindingReducer()
    Reduce { state, action in
      switch action {
      case .submitButtonTapped where state.code.count < 4:
        state.alert = AlertState { TextState("코드는 4자리 이상입니다") }
        return .none
      case .submitButtonTapped:
        state.isRequestInFlight = true
        return .none
      case .alert, .binding:
        return .none
      }
    }
    .ifLet(\.$alert, action: \.alert)
  }
}

final class CodeEntryViewController: UIViewController {
  @UIBindable var store: StoreOf<CodeEntry>        // SwiftUI의 @Bindable 자리

  init(store: StoreOf<CodeEntry>) {
    self.store = store
    super.init(nibName: nil, bundle: nil)
  }
  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }

  override func viewDidLoad() {
    super.viewDidLoad()
    let codeField = UITextField(text: $store.code)  // 양방향 바인딩 (Day 4의 $store.text)
    let submitButton = UIButton(type: .system, primaryAction: UIAction { [weak self] _ in
      self?.store.send(.submitButtonTapped)
    })
    let spinner = UIActivityIndicatorView(style: .medium)
    view.addSubview(UIStackView(arrangedSubviews: [codeField, submitButton, spinner]))

    observe { [weak self] in
      guard let self else { return }
      spinner.isHidden = !store.isRequestInFlight
      submitButton.isEnabled = !store.isRequestInFlight
    }

    // 상태가 nil이 아니게 되면 띄우고, 닫히면 nil로 되돌린다 (Day 10의 .alert($store.scope…))
    present(item: $store.scope(\.alert, action: \.alert)) { store in
      UIAlertController(store: store)
    }
  }
}

final class AppController: NavigationStackController {
  private var store: StoreOf<AppFeature>!

  convenience init(store: StoreOf<AppFeature>) {
    @UIBindable var store = store

    self.init(path: $store.scope(\.path, action: \.path)) {
      UIHostingController(rootView: Text("SyncUps 목록"))    // 루트는 SwiftUI여도 된다
    } destination: { store in
      switch store.case {
      case let .detail(store):
        UIHostingController(rootView: Text(store.title))
      case let .record(store):
        UIHostingController(rootView: Text("회의 중: \(store.title)"))
      }
    }
    self.store = store
  }
}

struct User: Equatable, Sendable { var id: Int }
struct Movie: Equatable, Sendable { var title: String }

@DependencyClient
struct MovieClient {
  var fetchCurrentUser: @Sendable () async throws -> User
  var fetchMovies: @Sendable (_ userID: Int) async throws -> [Movie]
}
extension MovieClient: TestDependencyKey { static let testValue = Self() }
extension DependencyValues {
  var movieClient: MovieClient {
    get { self[MovieClient.self] }
    set { self[MovieClient.self] = newValue }
  }
}

@Reducer
struct Movies {
  @ObservableState
  struct State: Equatable { var movies: [Movie] = [] }
  enum Action {
    case refreshButtonTapped
    case moviesResponse([Movie])
  }
  @Dependency(\.movieClient) var movieClient

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .refreshButtonTapped:
        return .run { send in
          // 사이에 상태를 바꿀 일이 없으면 한 이펙트 안에서 이어서 await
          let user = try await movieClient.fetchCurrentUser()
          let movies = try await movieClient.fetchMovies(userID: user.id)
          await send(.moviesResponse(movies))
        }
      case let .moviesResponse(movies):
        state.movies = movies
        return .none
      }
    }
  }
}