Day 13 · 1부 · 성능 — 액션 비용·고빈도 액션·스코프·관찰 범위

@Reducer
struct NoteEditor {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var isEnabled = false
    var text = ""
    var summary = ""
  }
  enum Action {
    case buttonTapped
    case toggleChanged
    case textFieldChanged(String)
    case sharedComputation            // 사용자가 한 일이 아닌 내부 액션
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .buttonTapped:
        state.count += 1
        return .send(.sharedComputation)
      case .toggleChanged:
        state.isEnabled.toggle()
        return .send(.sharedComputation)
      case let .textFieldChanged(text):
        state.text = text
        return .send(.sharedComputation)
      case .sharedComputation:
        state.summary = "\(state.count) · \(state.isEnabled) · \(state.text.count)자"
        return .none
      }
    }
  }
}

@Reducer
struct NoteEditorFixed {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var isEnabled = false
    var text = ""
    var summary = ""
  }
  enum Action {
    case buttonTapped
    case toggleChanged
    case textFieldChanged(String)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .buttonTapped:
        state.count += 1
        return sharedComputation(state: &state)
      case .toggleChanged:
        let effect = sharedComputation(state: &state)   // 먼저 돌리는 것도 가능하지만
        state.isEnabled.toggle()                          // 순서가 결과를 바꾼다: summary는 토글 전 값으로
                                                          // 계산돼 isEnabled=true인데 "0 · false · 0자"가 남는다
        return effect
      case let .textFieldChanged(text):
        state.text = text
        return sharedComputation(state: &state)
      }
    }
  }

  func sharedComputation(state: inout State) -> Effect<Action> {
    state.summary = "\(state.count) · \(state.isEnabled) · \(state.text.count)자"
    return .none                 // 필요하면 .run { … }도 돌려줄 수 있다
  }
}

@MainActor
func testNoteEditor() async {
  let store = TestStore(initialState: NoteEditorFixed.State()) { NoteEditorFixed() }
  await store.send(.buttonTapped) {
    $0.count = 1
    $0.summary = "1 · false · 0자"
  }
  await store.send(.textFieldChanged("hi")) {
    $0.text = "hi"
    $0.summary = "1 · false · 2자"
  }
}

case .analyzeButtonTapped:
  var total = 0
  for value in state.samples {
    total &+= value &* value        // 무거운 계산이라고 치자
  }
  state.result = total
  return .none

@Reducer
struct Analyzer {
  @ObservableState
  struct State: Equatable {
    var samples: [Int] = Array(0..<100_000)
    var result: Int?
  }
  enum Action {
    case analyzeButtonTapped
    case analysisResponse(Int)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .analyzeButtonTapped:
        return .run { [samples = state.samples] send in     // 필요한 값만 복사해 캡처
          var total = 0
          for (index, value) in samples.enumerated() {
            total &+= value &* value
            if index.isMultiple(of: 1_000) {
              await Task.yield()                            // 스레드 풀에 양보
            }
          }
          await send(.analysisResponse(total))
        }
      case let .analysisResponse(total):
        state.result = total
        return .none
      }
    }
  }
}

@Reducer
struct Importer {
  @ObservableState
  struct State: Equatable { var progress = 0.0 }
  enum Action { case startButtonTapped, progress(Double) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .startButtonTapped:
        return .run { send in
          let total = 100_000
          let interval = max(total / 100, 1)
          for step in 0..<total {
            // 한 단계 작업…
            if step.isMultiple(of: interval) {
              await send(.progress(Double(step) / Double(total)))
            }
          }
          await send(.progress(1))
        }
      case let .progress(value):
        state.progress = value
        return .none
      }
    }
  }
}

@Reducer
struct PhotoAdjust {
  @ObservableState
  struct State: Equatable { var opacity = 1.0 }
  enum Action { case setOpacity(Double) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .setOpacity(value):
        state.opacity = value          // 저장·분석 같은 무거운 후처리도 여기서 1번만
        return .none
      }
    }
  }
}

struct PhotoAdjustView: View {
  let store: StoreOf<PhotoAdjust>
  @State private var opacity = 1.0

  var body: some View {
    Slider(value: $opacity, in: 0...1) { isEditing in
      if !isEditing { store.send(.setOpacity(opacity)) }
    }
    .onAppear { opacity = store.opacity }
  }
}

extension Dashboard.State {
  var computedStats: Stats.State {
    Stats.State(prices: prices.filter { $0 > 0 }.sorted())   // 읽을 때마다 전체 순회·정렬
  }
}
// 뷰에서
StatsView(store: store.scope(\.computedStats, action: \.stats))

@Reducer
struct Stats {
  @ObservableState
  struct State: Equatable {
    var prices: [Int] = []
    var total: Int { prices.reduce(0, +) }     // 자식 안에서 계산
  }
  enum Action { case refreshTapped }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }
  }
}

@Reducer
struct Dashboard {
  @ObservableState
  struct State: Equatable {
    var prices: [Int] = []
    var stats = Stats.State()      // 저장 프로퍼티 — 가격이 바뀔 때 리듀서가 채운다
  }
  enum Action { case priceAdded(Int), stats(Stats.Action) }
  var body: some ReducerOf<Self> {
    Scope(\.stats, action: \.stats) { Stats() }
    Reduce { state, action in
      switch action {
      case let .priceAdded(price):
        state.prices.append(price)
        state.stats.prices = state.prices.filter { $0 > 0 }   // 바뀔 때 한 번만
        return .none
      case .stats:
        return .none
      }
    }
  }
}

struct StatsView: View {
  let store: StoreOf<Stats>
  var body: some View { Text("합계 \(store.total)") }
}

struct DashboardView: View {
  let store: StoreOf<Dashboard>
  var body: some View {
    StatsView(store: store.scope(\.stats, action: \.stats))   // 단순 getter 키패스
  }
}