Day 7 · 1부 · 의존성 — @Dependency와 등록

@Reducer
struct AddTodo {
  @ObservableState
  struct State: Equatable {
    var todos: [Todo] = []
    var toast: String?
  }
  enum Action { case addButtonTapped, toastTimerFired }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        state.todos.append(Todo(id: UUID(), title: "", createdAt: Date()))  // 매번 다른 값
        state.toast = "추가했다"
        return .run { send in
          try await Task.sleep(for: .seconds(2))   // 테스트도 진짜 2초를 기다린다
          await send(.toastTimerFired)
        }
      case .toastTimerFired:
        state.toast = nil
        return .none
      }
    }
  }
}

protocol NowProviding: Sendable { func now() -> Date }
struct SystemNow: NowProviding { func now() -> Date { Date() } }

extension EnvironmentValues {
  @Entry var nowProvider: any NowProviding = SystemNow()
}

@Observable
final class StampModel {
  var stamps: [Date] = []
  private let nowProvider: any NowProviding
  init(nowProvider: any NowProviding) { self.nowProvider = nowProvider }   // 생성자로만 받을 수 있다
  func stamp() { stamps.append(nowProvider.now()) }
}

struct StampScreen: View {
  @Environment(\.nowProvider) private var nowProvider   // 뷰에서만 읽힌다
  @State private var model: StampModel?

  var body: some View {
    Button("찍기") { model?.stamp() }
      .task { if model == nil { model = StampModel(nowProvider: nowProvider) } }
  }
}

struct Todo: Equatable, Identifiable {
  let id: UUID
  var title: String
  var createdAt: Date
}

@Reducer
struct Todos {
  @ObservableState
  struct State: Equatable {
    var todos: IdentifiedArrayOf<Todo> = []
    var toast: String?
  }
  enum Action { case addButtonTapped, toastTimerFired }

  @Dependency(\.uuid) var uuid                // UUID() 대신
  @Dependency(\.date.now) var now             // Date() 대신
  @Dependency(\.continuousClock) var clock    // Task.sleep 대신

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        state.todos.append(Todo(id: uuid(), title: "", createdAt: now))
        state.toast = "추가했다"
        return .run { send in
          try await clock.sleep(for: .seconds(2))
          await send(.toastTimerFired)
        }
      case .toastTimerFired:
        state.toast = nil
        return .none
      }
    }
  }
}

import Testing

@MainActor
@Test func 할일을_추가하면_토스트가_2초_뒤_사라진다() async {
  let store = TestStore(initialState: Todos.State()) {
    Todos()
  } withDependencies: {
    $0.uuid = .incrementing                                   // 00000000-…-000000000000부터
    $0.date.now = Date(timeIntervalSinceReferenceDate: 0)
    $0.continuousClock = ImmediateClock()                     // sleep이 즉시 끝난다
  }

  await store.send(.addButtonTapped) {
    $0.todos = [Todo(id: UUID(0), title: "", createdAt: Date(timeIntervalSinceReferenceDate: 0))]
    $0.toast = "추가했다"
  }
  await store.receive(\.toastTimerFired) {
    $0.toast = nil
  }
}

@Observable
final class ToastModel {
  var toast: String?
  private let clock: any Clock<Duration>

  init(clock: any Clock<Duration> = ContinuousClock()) {
    self.clock = clock
  }

  func show() async {
    toast = "추가했다"
    try? await clock.sleep(for: .seconds(2))
    toast = nil
  }
}

@Observable
final class ToastModelWithDeps {
  var toast: String?
  @ObservationIgnored @Dependency(\.continuousClock) var clock   // 생성자 인자가 사라진다

  func show() async {
    toast = "추가했다"
    try? await clock.sleep(for: .seconds(2))
    toast = nil
  }
}

// ① 인터페이스: 클로저를 담은 struct (프로토콜과의 비교는 2부)
struct NumberFactClient: Sendable {
  var fetch: @Sendable (Int) async throws -> String
}

// ② 키 채택: 상황별 구현을 준다
extension NumberFactClient: DependencyKey {
  static let liveValue = NumberFactClient(
    fetch: { number in
      let url = URL(string: "http://numbersapi.com/\(number)")!
      let (data, _) = try await URLSession.shared.data(from: url)
      return String(decoding: data, as: UTF8.self)
    }
  )
  static let previewValue = NumberFactClient(
    fetch: { "\($0)은(는) Preview용 숫자다." }       // 즉시 가짜 데이터
  )
  static let testValue = NumberFactClient(
    fetch: { _ in
      reportIssue("NumberFactClient.fetch를 테스트에서 덮어쓰지 않았다")
      return ""
    }
  )
}

// ③ 값 가방에 통로: @Dependency(\.numberFact)로 꺼낼 수 있게
extension DependencyValues {
  var numberFact: NumberFactClient {
    get { self[NumberFactClient.self] }
    set { self[NumberFactClient.self] = newValue }
  }
}

// ④ 어느 리듀서에서든 꺼내 쓴다 — 결과는 액션으로 되돌린다 (Day 3)
@Reducer
struct NumberFact {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
  }
  enum Action {
    case factButtonTapped
    case factResponse(String)
  }

  @Dependency(\.numberFact) var numberFact

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .factButtonTapped:
        return .run { [count = state.count] send in
          do {
            await send(.factResponse(try await numberFact.fetch(count)))
          } catch {
            await send(.factResponse("불러오지 못했다"))
          }
        }
      case let .factResponse(fact):
        state.fact = fact
        return .none
      }
    }
  }
}

protocol Greeter: Sendable { func greet(_ name: String) -> String }
struct LiveGreeter: Greeter { func greet(_ name: String) -> String { "안녕하세요, \(name)님" } }
struct MockGreeter: Greeter { func greet(_ name: String) -> String { "mock \(name)" } }

extension DependencyValues {
  @DependencyEntry(liveValue: LiveGreeter())
  // 오른쪽 기본값이 testValue가 된다
  var greeter: any Greeter = MockGreeter()
}

@DependencyClient
struct FactClient: Sendable {
  var fetch: @Sendable (_ number: Int) async throws -> String
  var isFavorite: @Sendable (_ number: Int) -> Bool = { _ in false }   // 기본값 필수 (아래)
}

extension FactClient: DependencyKey {
  static let liveValue = FactClient(
    fetch: { number in "\(number)은(는) 멋진 숫자다" },
    isFavorite: { $0 == 7 }
  )
  static let testValue = FactClient()        // 모든 엔드포인트가 "미구현"
}

extension DependencyValues {
  var fact: FactClient {
    get { self[FactClient.self] }
    set { self[FactClient.self] = newValue }
  }
}

func useFact() async throws {
  @Dependency(\.fact) var fact
  let text = try await fact.fetch(number: 42)   // 라벨 있는 메서드가 생겼다
  print(text, fact.isFavorite(number: 42))
}