Day 7 · 2부 · 의존성 — 설계·오버라이드·수명

protocol AudioPlayer: Sendable {
  func play(url: URL) async throws
  func stop() async
}

struct LiveAudioPlayer: AudioPlayer {
  func play(url: URL) async throws { try await Task.sleep(for: .seconds(1)) }  // 실제로는 AVFoundation
  func stop() async {}
}

struct UnimplementedAudioPlayer: AudioPlayer {         // 테스트용: 부르면 실패
  func play(url: URL) async throws { reportIssue("AudioPlayer.play is unimplemented") }
  func stop() async { reportIssue("AudioPlayer.stop is unimplemented") }
}

private enum AudioPlayerKey: DependencyKey {
  static let liveValue: any AudioPlayer = LiveAudioPlayer()
  static let testValue: any AudioPlayer = UnimplementedAudioPlayer()
}

extension DependencyValues {
  var audioPlayer: any AudioPlayer {
    get { self[AudioPlayerKey.self] }
    set { self[AudioPlayerKey.self] = newValue }
  }
}

@DependencyClient
struct AudioPlayerClient: Sendable {
  var play: @Sendable (_ url: URL) async throws -> Void
  var stop: @Sendable () async -> Void
}

extension AudioPlayerClient: DependencyKey {
  static let liveValue = AudioPlayerClient(
    play: { _ in try await Task.sleep(for: .seconds(1)) },   // 실제로는 AVFoundation
    stop: {}
  )
  static let testValue = AudioPlayerClient()     // 모든 엔드포인트가 미구현 (1부)
}

extension DependencyValues {
  var audioPlayerClient: AudioPlayerClient {
    get { self[AudioPlayerClient.self] }
    set { self[AudioPlayerClient.self] = newValue }
  }
}

@Reducer
struct Player {
  @ObservableState
  struct State: Equatable { var isPlaying = false }
  enum Action { case playButtonTapped, playbackFinished }

  @Dependency(\.audioPlayerClient) var audioPlayer
  let url = URL(string: "https://example.com/intro.m4a")!

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .playButtonTapped:
        state.isPlaying = true
        return .run { [url] send in
          try? await audioPlayer.play(url: url)
          await send(.playbackFinished)
        }
      case .playbackFinished:
        state.isPlaying = false
        return .none
      }
    }
  }
}

import Testing

@MainActor
@Test func 재생버튼은_play를_한번_부른다() async {
  let played = LockIsolated<[URL]>([])            // 이펙트에서 안전하게 기록
  let store = TestStore(initialState: Player.State()) {
    Player()
  } withDependencies: {
    $0.audioPlayerClient.play = { url in played.withValue { $0.append(url) } }
  }

  await store.send(.playButtonTapped) { $0.isPlaying = true }
  await store.receive(\.playbackFinished) { $0.isPlaying = false }
  #expect(played.value == [URL(string: "https://example.com/intro.m4a")!])
}

struct AnalyticsClient: Sendable {
  var track: @Sendable (_ event: String, _ properties: [String: String]) async throws -> Void
  var isEnabled: @Sendable () -> Bool
}

extension AnalyticsClient: TestDependencyKey {
  static let testValue = AnalyticsClient(
    track: unimplemented("AnalyticsClient.track"),
    isEnabled: unimplemented("AnalyticsClient.isEnabled", placeholder: false)
  )
}

@DependencyClient
struct SettingsClient: Sendable {
  var save: @Sendable (_ key: String, _ value: Bool) async throws -> Void
}
extension SettingsClient: DependencyKey {
  static let liveValue = SettingsClient(save: { key, value in
    UserDefaults.standard.set(value, forKey: key)
  })
  static let inMemory = SettingsClient(save: { _, _ in })   // 아무 데도 쓰지 않는다
}
extension DependencyValues {
  var settingsClient: SettingsClient {
    get { self[SettingsClient.self] }
    set { self[SettingsClient.self] = newValue }
  }
}

@Reducer
struct Settings {
  @ObservableState
  struct State: Equatable { var notificationsOn = false }
  enum Action { case notificationsToggled }
  @Dependency(\.settingsClient) var settingsClient

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.notificationsOn.toggle()
      return .run { [on = state.notificationsOn] _ in
        try await settingsClient.save(key: "notifications", value: on)
      } catch: { _, _ in }
    }
  }
}

@Reducer
struct Onboarding {
  @ObservableState
  struct State: Equatable { var settings = Settings.State() }
  enum Action { case settings(Settings.Action) }

  var body: some ReducerOf<Self> {
    Scope(\.settings, action: \.settings) {
      Settings()
        .dependency(\.settingsClient, .inMemory)   // 이 서브트리와 그 이펙트에만 적용
    }
  }
}

struct PlayerView: View {
  let store: StoreOf<Player>
  var body: some View {
    Button(store.isPlaying ? "재생 중" : "재생") { store.send(.playButtonTapped) }
  }
}

#Preview("재생 실패") {
  PlayerView(
    store: Store(initialState: Player.State()) {
      Player()
    } withDependencies: {
      $0.audioPlayerClient.play = { _ in
        struct Boom: Error {}
        throw Boom()
      }
    }
  )
}

return .run { send in
  DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    @Dependency(\.settingsClient) var settingsClient   // .inMemory가 아니라 liveValue
    Task { try await settingsClient.save(key: "seen", value: true) }
  }
}

@Reducer
struct Reminder {
  struct State: Equatable {}
  enum Action { case appeared, delayedCallbackFired }
  @Dependency(\.continuousClock) var clock

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .appeared:
        return .run { send in
          try await clock.sleep(for: .seconds(2))           // ① 구조적 동시성 — 그대로 상속된다
          await send(.delayedCallbackFired)
        }
      case .delayedCallbackFired:
        return .run { _ in
          withEscapedDependencies { dependencies in          // ② 콜백 API를 써야 할 때
            DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
              dependencies.yield {
                // 이 안에서는 withEscapedDependencies를 부른 시점의 의존성이 쓰인다
              }
            }
          }
        }
      }
    }
  }
}

@Observable
final class EditModel {
  @ObservationIgnored @Dependency(\.audioPlayerClient) var audioPlayer
}

@Observable
final class LibraryModel {
  var edit: EditModel?
  @ObservationIgnored @Dependency(\.audioPlayerClient) var audioPlayer

  func editTapped() {
    // edit = EditModel()   ← 이렇게 만들면 앱 기본값(liveValue)으로 돌아간다
    edit = withDependencies(from: self) {   // 부모가 쓰는 의존성을 그대로 물려준다
      EditModel()
    }
  }
}

@Reducer
struct Quote {
  @ObservableState
  struct State: Equatable { var text: String?; var fetchedAt: Date? }
  enum Action { case refreshTapped, quoteLoaded(String) }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .refreshTapped:
        state.fetchedAt = Date()                           // 통제 밖
        return .run { send in
          let (data, _) = try await URLSession.shared      // 통제 밖
            .data(from: URL(string: "https://example.com/quote")!)
          await send(.quoteLoaded(String(decoding: data, as: UTF8.self)))
        }
      case let .quoteLoaded(text):
        state.text = text
        return .none
      }
    }
  }
}