Day 2 · 첫 기능 — Reducer와 Store

import ComposableArchitecture

@Reducer
struct CounterFeature {
  @ObservableState
  struct State: Equatable {       // Equatable: 나중에 TestStore가 비교할 때 필요
    var count = 0
  }

  enum Action {
    case decrementButtonTapped    // 사용자가 한 일로 이름 짓기
    case incrementButtonTapped
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in     // state는 inout — 그 자리에서 바꾼다
      switch action {
      case .decrementButtonTapped:
        state.count -= 1
        return .none              // 실행할 Effect 없음
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

enum Action {
  case incrementCount          // "무엇을 하라"
  case setNumberFact(String)   // setter처럼 쓰는 Action
  case saveItem
}

import ComposableArchitecture
import SwiftUI

struct CounterView: View {
  let store: StoreOf<CounterFeature>   // = Store<CounterFeature.State, CounterFeature.Action>

  var body: some View {
    VStack(spacing: 16) {
      Text("\(store.count)")             // State 프로퍼티를 바로 읽는다
        .font(.largeTitle)
        .monospacedDigit()
      HStack {
        Button("-") { store.send(.decrementButtonTapped) }
        Button("+") { store.send(.incrementButtonTapped) }
      }
      .font(.largeTitle)
      .buttonStyle(.bordered)
    }
  }
}

import ComposableArchitecture
import SwiftUI

@main
struct CounterApp: App {
  static let store = Store(initialState: CounterFeature.State()) {
    CounterFeature()
  }

  var body: some Scene {
    WindowGroup {
      CounterView(store: CounterApp.store)
    }
  }
}

struct ParentView: View {
  @State private var isOn = false

  var body: some View {
    VStack {
      Toggle("아무 설정", isOn: $isOn)        // 토글하면 ParentView.body 재실행
      CounterView(
        store: Store(initialState: CounterFeature.State()) {   // 매번 새 Store
          CounterFeature()
        }
      )
    }
  }
}

import ComposableArchitecture
import SwiftUI

struct OwningParentView: View {
  @State private var isOn = false
  @StateObject private var store: StoreOf<CounterFeature>

  init() {
    _store = StateObject(
      wrappedValue: Store(initialState: CounterFeature.State()) {
        CounterFeature()
      }
    )
  }

  var body: some View {
    VStack {
      Toggle("아무 설정", isOn: $isOn)
      CounterView(store: store)          // 같은 Store가 유지된다
    }
  }
}

import ComposableArchitecture
import SwiftUI

#Preview("동작") {
  CounterView(
    store: Store(initialState: CounterFeature.State(count: 42)) {
      CounterFeature()
        ._printChanges()      // Preview 콘솔에도 Action과 State diff가 찍힌다
    }
  )
}

#Preview("디자인만") {
  CounterView(
    store: Store(initialState: CounterFeature.State(count: 42)) {
      // 비워 두면 아무 일도 하지 않는 Reducer가 된다. 버튼을 눌러도 42 그대로
    }
  )
}

import ComposableArchitecture

struct ExpandedCounter {
  struct State: Equatable { var count = 0 }

  @CasePathable                       // ① Action에 케이스 키패스
  enum Action { case incrementButtonTapped }

  @ComposableArchitecture.ReducerBuilder<Self.State, Self.Action>   // ② body에 결과 빌더
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

extension ExpandedCounter: ComposableArchitecture.Reducer {}   // ③ 프로토콜 채택

struct ExpandedState {       // 원래 이름은 State
  var count {
    @storageRestrictions(initializes: _count)
    init(initialValue) { _count = initialValue }
    get {
      _$observationRegistrar.access(self, keyPath: \.count)     // "읽었다" 기록
      return _count
    }
    set {
      _$observationRegistrar.mutate(self, keyPath: \.count, &_count, newValue,
                                    _$isIdentityEqual, shouldNotifyObservers)
    }
    _modify { /* willModify … didModify */ }
  }

  var _$observationRegistrar = ComposableArchitecture.ObservationStateRegistrar()
  public var _$id: ComposableArchitecture.ObservableStateID { _$observationRegistrar.id }
  public mutating func _$willModify() { _$observationRegistrar._$willModify() }

  // Equatable 값이면 lhs != rhs 일 때만 알린다
  private nonisolated func shouldNotifyObservers<T: Equatable>(_ lhs: T, _ rhs: T) -> Bool {
    lhs != rhs
  }
}
// + extension: Observable, ObservableState 채택 (매크로 선언의 conformances)

import ComposableArchitecture
import SwiftUI

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

struct CountLabel: View {
  let store: StoreOf<ProfileCounter>
  var body: some View {
    let _ = Self._printChanges()   // 다시 그려질 때만 찍힌다
    Text("\(store.count)")          // count만 읽는다 → name 변경에는 반응 안 함
  }
}

import SwiftUI
import Testing

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

@MainActor
@Test func plainCounter() {
  let model = PlainCounter()
  model.increment()
  #expect(model.count == 1)
  model.decrement()
  #expect(model.count == 0)
}

import ComposableArchitecture
import Testing

@MainActor
@Test func counterFeature() async {
  let store = TestStore(initialState: CounterFeature.State()) {
    CounterFeature()
  }
  await store.send(.incrementButtonTapped) {
    $0.count = 1
  }
  await store.send(.decrementButtonTapped) {
    $0.count = 0
  }
}

import ComposableArchitecture
import Testing

@MainActor
@Test func stepCounter() async {
  let store = TestStore(initialState: StepCounter.State()) { StepCounter() }
  await store.send(.stepIncrementButtonTapped) { $0.step = 2 }
  await store.send(.incrementButtonTapped) { $0.count = 2 }
  await store.send(.decrementButtonTapped) { $0.count = 0 }
  await store.send(.incrementButtonTapped) { $0.count = 2 }
  await store.send(.resetButtonTapped) {
    $0.count = 0
    $0.step = 1
  }
}