Day 1 · 왜 TCA인가

import SwiftUI

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

    func search() async {
        isLoading = true
        // 네트워크를 모델 안에서 직접 부른다
        let url = URL(string: "https://example.com/search?q=\(query)")!
        let data = (try? await URLSession.shared.data(from: url).0) ?? Data()
        results = String(decoding: data, as: UTF8.self)
            .split(separator: "\n").map(String.init)
        isLoading = false
    }
}

import SwiftUI

struct SearchScreen: View {
    @State private var model = SearchModel()

    var body: some View {
        List(model.results, id: \.self) { Text($0) }
            .searchable(text: $model.query)             // ① 바인딩이 바꾼다
            .onChange(of: model.query) {
                if model.query.isEmpty { model.results = [] }   // ② onChange가 바꾼다
            }
            .task { await model.search() }              // ③ 메서드가 바꾼다
            .toolbar {
                Button("지우기") {
                    model.query = ""                    // ④ 버튼 클로저가 바꾼다
                    model.results = []
                }
            }
    }
}

import Testing

@MainActor
@Test func searchLoadsResults() async {
    let model = SearchModel()
    model.query = "swift"
    await model.search()              // 진짜 URLSession 호출
    #expect(model.results.isEmpty == false)   // 서버·네트워크에 따라 성공/실패
    #expect(model.isLoading == false)  // 중간에 true였는지는 확인할 방법이 없다
}

import ComposableArchitecture

@Reducer
struct Feature {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var numberFact: String?
  }

  enum Action {
    case decrementButtonTapped
    case incrementButtonTapped
    case numberFactButtonTapped
    case numberFactResponse(String)     // 이펙트가 돌려주는 "보이지 않는 사건"
  }

  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .decrementButtonTapped:
        state.count -= 1
        return .none                    // 할 바깥 일 없음

      case .incrementButtonTapped:
        state.count += 1
        return .none

      case .numberFactButtonTapped:
        return .run { [count = state.count] send in    // 바깥 일을 "값"으로 반환
          let (data, _) = try await URLSession.shared.data(
            from: URL(string: "http://number-trivia.com/\(count)/trivia")!
          )
          await send(.numberFactResponse(String(decoding: data, as: UTF8.self)))
        }

      case let .numberFactResponse(fact):
        state.numberFact = fact
        return .none
      }
    }
  }
}

import ComposableArchitecture
import SwiftUI

struct FeatureView: View {
  let store: StoreOf<Feature>

  var body: some View {
    Form {
      Section {
        Text("\(store.count)")
        Button("Decrement") { store.send(.decrementButtonTapped) }
        Button("Increment") { store.send(.incrementButtonTapped) }
      }
      Section {
        Button("Number fact") { store.send(.numberFactButtonTapped) }
      }
      if let fact = store.numberFact {
        Text(fact)
      }
    }
  }
}

struct BadFeatureView: View {
  let store: StoreOf<Feature>

  var body: some View {
    Button("+") {
      store.count += 1     // error: left side of mutating operator isn't mutable
    }
  }
}

import SwiftUI

@Observable final class CounterModel {
  var count = 0
}

struct ObservableCounterButton: View {
  let model: CounterModel
  var body: some View {
    Button("+") { model.count += 1 }      // 어디서든 대입 가능
  }
}

struct TCACounterButton: View {
  let store: StoreOf<Feature>
  var body: some View {
    Button("+") { store.send(.incrementButtonTapped) }   // "무슨 일이 있었나"만 알린다
  }
}

import ComposableArchitecture
import SwiftUI

@main
struct NumberFactApp: App {
  static let store = Store(initialState: Feature.State()) {
    Feature()
      ._printChanges()        // DEBUG 빌드에서 Action과 State diff 출력
  }

  var body: some Scene {
    WindowGroup {
      FeatureView(store: Self.store)
    }
  }
}

import ComposableArchitecture
import Testing

@MainActor
@Test func incrementThenDecrement() async {
  let store = TestStore(initialState: Feature.State()) {
    Feature()
  }
  await store.send(.incrementButtonTapped) {
    $0.count = 1          // "이렇게 바뀌어야 한다"를 적는다. 틀리면 테스트 실패
  }
  await store.send(.decrementButtonTapped) {
    $0.count = 0
  }
}

import SwiftUI

@Observable final class TallyModel {
  var count = 0
  func increment() { count += 1 }
}

import ComposableArchitecture

@Reducer
struct TallyFeature {
  @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
      }
    }
  }
}

import ComposableArchitecture

struct User: Equatable, Sendable { var id: Int }

@Reducer
struct MoviesFeature {
  @ObservableState
  struct State: Equatable {
    var isLoading = false
    var movies: [String] = []
  }
  enum Action {
    case refreshButtonTapped
    case moviesResponse([String])
  }
  let fetchUser: @Sendable () async -> User       // 의존성은 Day 7에서 제대로
  let fetchMovies: @Sendable (Int) async -> [String]

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .refreshButtonTapped:
        state.isLoading = true
        return .run { send in
          let user = await fetchUser()            // 두 요청을 한 Effect에서 연달아
          let movies = await fetchMovies(user.id)
          await send(.moviesResponse(movies))     // Action 왕복은 한 번
        }
      case let .moviesResponse(movies):
        state.isLoading = false
        state.movies = movies
        return .none
      }
    }
  }
}