Day 12 · 1부 · @Shared — 값 타입 앱에서 상태 공유하기

@Reducer
struct CopyParent {
  @ObservableState
  struct State: Equatable {
    var count = 0
    @Presents var child: CopyChild.State?
  }
  enum Action {
    case child(PresentationAction<CopyChild.Action>)
    case presentButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .presentButtonTapped:
        state.child = CopyChild.State(count: state.count)   // 여기서 복사된다
        return .none
      case .child:
        return .none
      }
    }
    .ifLet(\.$child, action: \.child) { CopyChild() }
  }
}

@Reducer
struct CopyChild {
  @ObservableState
  struct State: Equatable { var count: Int }
  enum Action { case incrementButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.count += 1        // 자식 복사본만 바뀐다
      return .none
    }
  }
}

@Reducer
struct ParentFeature {
  @ObservableState
  struct State: Equatable {
    @Shared var count: Int
    @Presents var child: ChildFeature.State?
  }
  enum Action {
    case child(PresentationAction<ChildFeature.Action>)
    case presentButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .presentButtonTapped:
        state.child = ChildFeature.State(count: state.$count)   // Shared<Int> 전달
        return .none
      case .child:
        return .none
      }
    }
    .ifLet(\.$child, action: \.child) { ChildFeature() }
  }
}

@Reducer
struct ChildFeature {
  @ObservableState
  struct State: Equatable { @Shared var count: Int }
  enum Action { case incrementButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.$count.withLock { $0 += 1 }   // 부모의 count도 같이 바뀐다
      return .none
    }
  }
}

// 루트에서 만들 때: 진실의 주인이 여기라면 Shared(value:)로 새로 만든다
let rootStore = Store(initialState: ParentFeature.State(count: Shared(value: 0))) {
  ParentFeature()
}

struct SignUpData: Equatable {
  var email = ""
  var phoneNumber = ""
}

@Reducer
struct PhoneNumberFeature {
  @ObservableState
  struct State: Equatable { @Shared var phoneNumber: String }   // 전체를 몰라도 된다
  enum Action { case clearButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.$phoneNumber.withLock { $0 = "" }
      return .none
    }
  }
}

@Reducer
struct SignUpFeature {
  @ObservableState
  struct State: Equatable {
    @Shared var signUpData: SignUpData
    @Presents var phone: PhoneNumberFeature.State?
  }
  enum Action {
    case nextButtonTapped
    case phone(PresentationAction<PhoneNumberFeature.Action>)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .nextButtonTapped:
        state.phone = PhoneNumberFeature.State(phoneNumber: state.$signUpData.phoneNumber)
        return .none
      case .phone:
        return .none
      }
    }
    .ifLet(\.$phone, action: \.phone) { PhoneNumberFeature() }
  }
}

@Observable
final class CounterModel {
  var count = 0
}

struct CounterParentView: View {
  @State private var model = CounterModel()
  @State private var isChildShown = false
  var body: some View {
    Button("부모: \(model.count)") { isChildShown = true }
      .sheet(isPresented: $isChildShown) {
        CounterChildView(model: model)     // 같은 인스턴스를 넘긴다
      }
  }
}

struct CounterChildView: View {
  let model: CounterModel
  var body: some View {
    Button("자식: \(model.count) +1") { model.count += 1 }   // 부모 화면도 바뀐다
  }
}

@Reducer
struct CounterTab {
  @ObservableState
  struct State: Equatable {
    @Shared(.appStorage("count")) var count = 0     // 기본값: 저장소가 비었을 때만 쓰인다
  }
  enum Action { case incrementButtonTapped, decrementButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .incrementButtonTapped:
        state.$count.withLock { $0 += 1 }
        return .none
      case .decrementButtonTapped:
        state.$count.withLock { $0 -= 1 }
        return .none
      }
    }
  }
}

@Reducer
struct ProfileTab {
  @ObservableState
  struct State: Equatable {
    @Shared(.appStorage("count")) var count = 0     // 같은 키 → 같은 참조
  }
  enum Action { case resetButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.$count.withLock { $0 = 0 }             // 카운터 탭 숫자도 0이 된다
      return .none
    }
  }
}

struct User: Codable, Equatable, Identifiable, Sendable {
  let id: Int
  var name: String
}

extension URL {
  static let usersURL = URL.documentsDirectory.appending(component: "users.json")
}

@Reducer
struct UsersFeature {
  @ObservableState
  struct State: Equatable {
    @Shared(.fileStorage(.usersURL)) var users: [User] = []
  }
  enum Action { case addButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.$users.withLock { $0.append(User(id: $0.count + 1, name: "새 사용자")) }
      return .none      // 파일 쓰기는 전략이 알아서 한다
    }
  }
}

struct SettingsView: View {
  @AppStorage("hapticsOn") private var hapticsOn = true   // 뷰가 소유, 바뀌면 body 재계산
  var body: some View {
    Toggle("햅틱", isOn: $hapticsOn)
  }
}

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

let currentCount = state.count
state.$count.withLock { $0 = currentCount + 1 }

@Reducer
struct ScoreFeature {
  @ObservableState
  struct State: Equatable {
    @Shared(.inMemory("score")) var score = 0
    @Shared(.inMemory("bestScore")) var bestScore = 0
  }
  enum Action { case pointScored }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      let newScore = state.$score.withLock { score -> Int in
        score += 1
        return score               // withLock은 클로저의 반환값을 돌려준다
      }
      state.$bestScore.withLock { $0 = max($0, newScore) }
      return .none
    }
  }
}

@Reducer
struct HapticsBadge {
  @ObservableState
  struct State: Equatable {
    @SharedReader var isHapticsEnabled: Bool     // 여기서 쓰기 시도 = 컴파일 에러
  }
  enum Action { case onAppear }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }
  }
}

@Reducer
struct SettingsFeature {
  @ObservableState
  struct State: Equatable {
    @Shared(.appStorage("isHapticsEnabled")) var isHapticsEnabled = true
    var badge: HapticsBadge.State
    init() {
      // $isHapticsEnabled를 init 안에서 바로 쓰면 빌드 에러
      // ("variable 'self._badge' used before being initialized") → Shared를 먼저 만들어 둘 다에 넘긴다
      let isHapticsEnabled = Shared(wrappedValue: true, .appStorage("isHapticsEnabled"))
      _isHapticsEnabled = isHapticsEnabled
      badge = HapticsBadge.State(isHapticsEnabled: SharedReader(isHapticsEnabled))
    }
  }
  enum Action { case badge(HapticsBadge.Action), toggleTapped }
  var body: some ReducerOf<Self> {
    Scope(\.badge, action: \.badge) { HapticsBadge() }
    Reduce { state, action in
      switch action {
      case .toggleTapped:
        state.$isHapticsEnabled.withLock { $0.toggle() }
        return .none
      case .badge:
        return .none
      }
    }
  }
}

// 목록 화면
@Shared(.fileStorage(.usersURL)) var users: [User] = []
// 다른 화면 (리팩터링 중 한 곳만 바꿈)
@Shared(.fileStorage(.usersURL)) var users: IdentifiedArrayOf<User> = []

extension SharedReaderKey where Self == FileStorageKey<IdentifiedArrayOf<User>>.Default {
  static var users: Self {
    Self[.fileStorage(.documentsDirectory.appending(component: "users.json")), default: []]
  }
}

extension SharedReaderKey where Self == AppStorageKey<Bool>.Default {
  static var isHapticsOn: Self {
    Self[.appStorage("isHapticsOn"), default: true]
  }
}

@Reducer
struct UserListFeature {
  @ObservableState
  struct State: Equatable {
    @Shared(.users) var users          // 타입·기본값 생략 가능
    @SharedReader(.isHapticsOn) var isHapticsOn
  }
  enum Action { case deleteButtonTapped(User.ID) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .deleteButtonTapped(id):
        _ = state.$users.withLock { $0.remove(id: id) }
        return .none
      }
    }
  }
}