Day 3 · Effect — 비동기와 취소

@Observable @MainActor
final class FactModel {
  var count = 0
  var fact: String?
  var isLoading = false

  func factButtonTapped() async {
    fact = nil
    isLoading = true
    defer { isLoading = false }
    fact = try? await FactAPI.fetch(count)   // 기다린 뒤 바로 대입
  }
}

struct FactScreen: View {
  @State private var model = FactModel()
  var body: some View {
    Button("숫자 상식") {
      Task { await model.factButtonTapped() }
    }
  }
}

Reduce { state, action in
  switch action {
  case .factButtonTapped:
    let (data, _) = try await URLSession.shared.data(from: url)
    state.fact = String(decoding: data, as: UTF8.self)
    return .none
  }
}
// error: cannot pass function of type '(inout State, Action) async throws -> Effect<Action>'
//        to parameter expecting synchronous function type

enum FactAPI {
  static func fetch(_ number: Int) async throws -> String {
    let url = URL(string: "http://number-trivia.com/\(number)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(decoding: data, as: UTF8.self)
  }
}

@Reducer
struct NumberFact {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
    var isLoading = false
  }
  enum Action {
    case factButtonTapped
    case factResponse(String)
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .factButtonTapped:
        state.fact = nil
        state.isLoading = true
        return .run { [count = state.count] send in
          let fact = try await FactAPI.fetch(count)
          await send(.factResponse(fact))      // 바깥 결과 → 액션
        }
      case let .factResponse(fact):
        state.fact = fact                      // 상태 변경은 여기서만
        state.isLoading = false
        return .none
      }
    }
  }
}

struct NumberFactView: View {
  let store: StoreOf<NumberFact>
  var body: some View {
    VStack {
      Button("숫자 상식") { store.send(.factButtonTapped) }
      if store.isLoading { ProgressView() }
      if let fact = store.fact { Text(fact) }
    }
  }
}

case .delayButtonTapped:
  return .run { send in
    try await Task.sleep(for: .seconds(1))
    await send(.delayed(state.count))
    // Swift 5: error: escaping closure captures 'inout' parameter 'state'
    // Swift 6: error: mutable capture of 'inout' parameter 'state' is not allowed
    //        in concurrently-executing code
  }

@Reducer
struct SafeFact {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
    var isLoading = false
    var errorMessage: String?
  }
  enum Action {
    case factButtonTapped
    case factResponse(Result<String, any Error>)
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .factButtonTapped:
        state.isLoading = true
        state.errorMessage = nil
        return .run { [count = state.count] send in
          await send(.factResponse(Result { try await FactAPI.fetch(count) }))
        }
      case let .factResponse(.success(fact)):
        state.isLoading = false
        state.fact = fact
        return .none
      case let .factResponse(.failure(error)):
        state.isLoading = false
        state.errorMessage = error.localizedDescription
        return .none
      }
    }
  }
}

@Reducer
struct CancellableFact {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
    var isLoading = false
  }
  enum Action {
    case cancelButtonTapped
    case factButtonTapped
    case factResponse(String)
    case stepperChanged(Int)
  }
  private enum CancelID { case factRequest }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .cancelButtonTapped:
        state.isLoading = false
        return .cancel(id: CancelID.factRequest)
      case .factButtonTapped:
        state.isLoading = true
        return .run { [count = state.count] send in
          let fact = try await FactAPI.fetch(count)
          await send(.factResponse(fact))
        }
        .cancellable(id: CancelID.factRequest)
      case let .factResponse(fact):
        state.isLoading = false
        state.fact = fact
        return .none
      case let .stepperChanged(value):
        state.count = value
        state.fact = nil
        state.isLoading = false
        return .cancel(id: CancelID.factRequest)   // 옛 숫자의 답은 필요 없다
      }
    }
  }
}

@Observable @MainActor
final class SearchModel {
  var query = ""
  var results: [String] = []

  func search() async {
    do {
      try await Task.sleep(for: .milliseconds(300))
      results = ["\(query) 결과"]
    } catch {}   // 새 글자가 들어와 취소되면 여기로
  }
}

struct SearchScreen: View {
  @State private var model = SearchModel()
  var body: some View {
    TextField("검색", text: $model.query)
      .task(id: model.query) { await model.search() }
  }
}

@Reducer
struct SearchDebounce {
  @ObservableState
  struct State: Equatable {
    var query = ""
    var results: [String] = []
  }
  enum Action {
    case queryChanged(String)
    case searchResponse([String])
  }
  @Dependency(\.continuousClock) var clock   // Day 7 예고: 테스트에서 시간을 갈아끼운다
  private enum CancelID { case search }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .queryChanged(query):
        state.query = query
        return .run { send in
          try await clock.sleep(for: .milliseconds(300))
          await send(.searchResponse(["\(query) 결과"]))
        }
        .cancellable(id: CancelID.search, cancelInFlight: true)
      case let .searchResponse(results):
        state.results = results
        return .none
      }
    }
  }
}

@Reducer
struct Stopwatch {
  @ObservableState
  struct State: Equatable {
    var isRunning = false
    var seconds = 0
  }
  enum Action {
    case toggleButtonTapped
    case timerTicked
  }
  @Dependency(\.continuousClock) var clock
  private enum CancelID { case timer }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .toggleButtonTapped:
        state.isRunning.toggle()
        guard state.isRunning else { return .cancel(id: CancelID.timer) }
        return .run { send in
          for await _ in clock.timer(interval: .seconds(1)) {
            await send(.timerTicked)
          }
        }
        .cancellable(id: CancelID.timer, cancelInFlight: true)
      case .timerTicked:
        state.seconds += 1
        return .none
      }
    }
  }
}

@Reducer
struct ScreenshotCounter {
  @ObservableState
  struct State: Equatable { var count = 0 }
  enum Action {
    case task
    case screenshotTaken
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .task:
        return .run { send in
          let shots = NotificationCenter.default.notifications(
            named: UIApplication.userDidTakeScreenshotNotification
          )
          for await _ in shots {
            await send(.screenshotTaken)
          }
        }
      case .screenshotTaken:
        state.count += 1
        return .none
      }
    }
  }
}

struct ScreenshotCounterView: View {
  let store: StoreOf<ScreenshotCounter>
  var body: some View {
    Text("스크린샷 \(store.count)번")
      .task { await store.send(.task).finish() }
  }
}

@Reducer
struct Countdown {
  @ObservableState
  struct State: Equatable {
    var remaining = 10
    var isRunning = false
  }
  enum Action {
    case startStopButtonTapped
    case tick
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .startStopButtonTapped:
        // TODO: isRunning 토글, 타이머 시작 또는 취소
        return .none
      case .tick:
        // TODO: 1 감소, 0이면 멈추기
        return .none
      }
    }
  }
}

struct CountdownView: View {
  let store: StoreOf<Countdown>
  var body: some View {
    VStack(spacing: 16) {
      Text("\(store.remaining)").font(.largeTitle).monospacedDigit()
      Button(store.isRunning ? "정지" : "시작") { store.send(.startStopButtonTapped) }
    }
  }
}

#Preview {
  CountdownView(store: Store(initialState: Countdown.State()) { Countdown() })
}