Day 5 · 조립 ① — Scope와 부모·자식

@Observable
final class CounterModel {
  var count = 0
  func incrementButtonTapped() { count += 1 }
  func decrementButtonTapped() { count -= 1 }
}

@Observable
final class TwoCountersModel {
  let counter1 = CounterModel()   // 자식은 참조 — 누가 바꿨는지는 추적 안 됨
  let counter2 = CounterModel()
}

@Reducer
struct Counter {
  @ObservableState
  struct State: Equatable {
    var count = 0
  }
  enum Action {
    case decrementButtonTapped
    case incrementButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .decrementButtonTapped:
        state.count -= 1
        return .none
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

@Reducer
struct TwoCounters {
  @ObservableState
  struct State: Equatable {
    var counter1 = Counter.State()   // 자식 상태 = 값
    var counter2 = Counter.State()
  }
  enum Action {
    case counter1(Counter.Action)    // 자식 액션을 감싸는 케이스
    case counter2(Counter.Action)
  }
  var body: some ReducerOf<Self> {
    Scope(\.counter1, action: \.counter1) { Counter() }
    Scope(\.counter2, action: \.counter2) { Counter() }
  }
}

struct CounterView: View {
  let store: StoreOf<Counter>       // 부모를 모른다
  var body: some View {
    HStack {
      Button("−") { store.send(.decrementButtonTapped) }
      Text("\(store.count)").monospacedDigit()
      Button("+") { store.send(.incrementButtonTapped) }
    }
  }
}

struct TwoCountersView: View {
  let store: StoreOf<TwoCounters>
  var body: some View {
    Form {
      CounterView(store: store.scope(\.counter1, action: \.counter1))
      CounterView(store: store.scope(\.counter2, action: \.counter2))
    }
    .buttonStyle(.borderless)
  }
}

#Preview {
  TwoCountersView(store: Store(initialState: TwoCounters.State()) { TwoCounters() })
}

// 부모 Reduce 안
case .edit(.saveButtonTapped):
  state.name = state.edit.draft   // 자식이 "저장 불가"라 판단해도 부모는 모른다
  return .none

@Reducer
struct ProfileEdit {
  @ObservableState
  struct State: Equatable {
    var draft = ""
  }
  enum Action {
    case draftChanged(String)
    case saveButtonTapped
    case delegate(Delegate)
    @CasePathable
    enum Delegate: Equatable {
      case saved(String)            // "이 이름으로 저장해 줘"
    }
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .draftChanged(text):
        state.draft = text
        return .none
      case .saveButtonTapped:
        let name = state.draft.trimmingCharacters(in: .whitespaces)
        guard !name.isEmpty else { return .none }   // 검증은 자식 몫
        return .send(.delegate(.saved(name)))
      case .delegate:
        return .none                  // 자식은 자기 delegate에 반응하지 않는다
      }
    }
  }
}

@Reducer
struct ProfileSettings {
  @ObservableState
  struct State: Equatable {
    var name = "Guest"
    var edit = ProfileEdit.State()
  }
  enum Action {
    case edit(ProfileEdit.Action)
  }
  var body: some ReducerOf<Self> {
    Scope(\.edit, action: \.edit) { ProfileEdit() }
    Reduce { state, action in
      switch action {
      case let .edit(.delegate(.saved(name))):
        state.name = name
        state.edit.draft = ""
        return .none
      case .edit:
        return .none                  // 나머지는 자식 내부 사정
      }
    }
  }
}

@Observable
final class ProfileEditModel {
  var draft = ""
  var onSaved: (String) -> Void = { _ in }   // 부모가 꽂아 준다
  func saveButtonTapped() {
    let name = draft.trimmingCharacters(in: .whitespaces)
    guard !name.isEmpty else { return }
    onSaved(name)
  }
}

@Observable
final class ProfileSettingsModel {
  var name = "Guest"
  let edit = ProfileEditModel()
  init() {
    edit.onSaved = { [weak self] name in      // 빠뜨리면 순환 참조
      self?.name = name
      self?.edit.draft = ""
    }
  }
}

@Reducer
struct Downloader {
  @ObservableState
  struct State: Equatable {
    var progress = 0.0
  }
  enum Action {
    case startButtonTapped
    case progressUpdated(Double)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .startButtonTapped:
        return .run { send in
          for step in 1...10 {
            try await Task.sleep(for: .milliseconds(300))
            await send(.progressUpdated(Double(step) / 10))
          }
        }
      case let .progressUpdated(value):
        state.progress = value
        return .none
      }
    }
  }
}

@Reducer
struct DownloadScreen {
  @ObservableState
  struct State: Equatable {
    var download: Downloader.State?
  }
  enum Action {
    case download(Downloader.Action)
    case toggleButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .toggleButtonTapped:
        state.download = state.download == nil ? Downloader.State() : nil
        return .none
      case .download:
        return .none
      }
    }
    .ifLet(\.download, action: \.download) {
      Downloader()
    }
  }
}

struct DownloadScreenView: View {
  let store: StoreOf<DownloadScreen>
  var body: some View {
    Form {
      Button("다운로드 패널 켜기/끄기") { store.send(.toggleButtonTapped) }
      if let childStore = store.scope(\.download, action: \.download) {
        ProgressView(value: childStore.progress)
        Button("시작") { childStore.send(.startButtonTapped) }
      } else {
        Text("패널 없음")
      }
    }
  }
}

@MainActor @Observable
final class DownloaderModel {
  var progress = 0.0
  private var task: Task<Void, Never>?
  func startButtonTapped() {
    task = Task { [weak self] in
      for step in 1...10 {
        try? await Task.sleep(for: .milliseconds(300))
        guard !Task.isCancelled else { return }
        self?.progress = Double(step) / 10
      }
    }
  }
  func cancel() { task?.cancel() }
}

@MainActor @Observable
final class DownloadScreenModel {
  var download: DownloaderModel?
  func toggleButtonTapped() {
    if let download {
      download.cancel()               // 빠뜨리면 화면 밖에서 계속 돈다
      self.download = nil
    } else {
      download = DownloaderModel()
    }
  }
}

var body: some ReducerOf<Self> {
  Reduce { state, action in
    // ...
    return .none
  }
  // .ifLet(\.download, action: \.download) { Downloader() }  ← 없음
  // → .download(.startButtonTapped)는 부모의 `case .download: return .none`에서 끝난다
}

@Reducer
struct Dashboard {
  @ObservableState
  struct State: Equatable {
    var left = Counter.State()
    var right = Counter.State()
  }
  enum Action {
    case left(Counter.Action)
    case right(Counter.Action)
  }
  var body: some ReducerOf<Self> {
    CombineReducers {
      Scope(\.left, action: \.left) { Counter() }
      Scope(\.right, action: \.right) { Counter() }
    }
    ._printChanges()                  // 묶음 전체에 한 번
  }
}

@Reducer
struct Checkout {
  @ObservableState
  struct State: Equatable {
    var quantity = 1
    var usesCoupon = false
    var total = 10_000
  }
  enum Action {
    case quantityChanged(Int)
    case couponToggled(Bool)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .quantityChanged(value):
        state.quantity = value
        return self.recalculate(&state)
      case let .couponToggled(isOn):
        state.usesCoupon = isOn
        return self.recalculate(&state)
      }
    }
  }
  private func recalculate(_ state: inout State) -> Effect<Action> {
    state.total = state.quantity * 10_000 - (state.usesCoupon ? 2_000 : 0)
    return .none                        // 필요하면 .run도 돌려줄 수 있다
  }
}