Day 12 · 2부 · 공유 상태 운영 — 초기화·커스텀 키·관찰·테스트

// ① 영속: 평범한 값을 받아 키와 함께 만든다. @autoclosure로 필요할 때만 평가
public struct PersistedCounterState: Equatable {
  @Shared public var count: Int
  public init(count: @autoclosure () -> Int = 0) {
    _count = Shared(wrappedValue: count(), .appStorage("count"))
  }
}

// ② 비영속 + 이 기능이 주인: 새 저장소를 만든다
public struct OwnedCounterState: Equatable {
  @Shared public var count: Int
  public init(count: Int) {
    _count = Shared(value: count)
  }
}

// ③ 비영속 + 부모가 주인: 받은 참조를 그대로 넣는다
public struct BorrowedCounterState: Equatable {
  @Shared public var count: Int
  public init(count: Shared<Int>) {
    _count = count
  }
}

struct UbiquitousKey<Value: Sendable>: SharedKey {
  let key: String
  var id: String { key }                      // 같은 id = 같은 참조

  func load(context: LoadContext<Value>, continuation: LoadContinuation<Value>) {
    if let value = NSUbiquitousKeyValueStore.default.object(forKey: key) as? Value {
      continuation.resume(returning: value)
    } else {
      continuation.resumeReturningInitialValue()   // 비었으면 선언의 기본값
    }
  }

  func subscribe(
    context: LoadContext<Value>, subscriber: SharedSubscriber<Value>
  ) -> SharedSubscription {
    let token = NotificationCenter.default.addObserver(
      forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,
      object: nil, queue: nil
    ) { [key] _ in
      if let value = NSUbiquitousKeyValueStore.default.object(forKey: key) as? Value {
        subscriber.yield(value)                // 다른 기기에서 바뀐 값을 밀어 넣는다
      }
    }
    let box = UncheckedSendable(token)
    return SharedSubscription { NotificationCenter.default.removeObserver(box.value) }
  }

  func save(_ value: Value, context: SaveContext, continuation: SaveContinuation) {
    NSUbiquitousKeyValueStore.default.set(value, forKey: key)
    continuation.resume()
  }
}

extension SharedReaderKey {
  static func ubiquitous<Value>(_ key: String) -> Self where Self == UbiquitousKey<Value> {
    UbiquitousKey(key: key)
  }
}

@Reducer
struct ReaderSettings {
  @ObservableState
  struct State: Equatable {
    @Shared(.ubiquitous("fontSize")) var fontSize = 14   // 내장 전략과 똑같이 쓴다
  }
  enum Action { case biggerTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, _ in
      state.$fontSize.withLock { $0 += 1 }
      return .none
    }
  }
}

struct Profile: Equatable {
  var nickname = ""
}

@Reducer
struct ProfileForm {
  @ObservableState
  struct State: Equatable { @Shared var profile: Profile }
  enum Action { case doneTapped }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }
  }
}

struct ProfileFormView: View {
  let store: StoreOf<ProfileForm>
  var body: some View {
    @Binding(store.$profile) var profile        // Shared → Binding
    Form {
      TextField("닉네임", text: $profile.nickname)   // 입력이 곧바로 공유 값에 쓰인다
      Text("미리보기: \(store.profile.nickname)")
    }
  }
}

@Reducer
struct CountWatcher {
  @ObservableState
  struct State: Equatable {
    @Shared(.appStorage("count")) var count = 0
    var milestone = ""
  }
  enum Action { case onAppear, countUpdated(Int) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .onAppear:
        return .publisher {
          state.$count.publisher.map { .countUpdated($0) }
        }
      case let .countUpdated(count):
        state.milestone = count.isMultiple(of: 10) ? "🎉 \(count)" : ""   // 다른 상태만 고친다
        return .none
      }
    }
  }
}

case let .countUpdated(count):
  state.$count.withLock { $0 = count + 1 }   // 또 방출 → 또 수신 → …
  return .none

@Reducer
struct SharedCounter {
  @ObservableState
  struct State: Equatable { @Shared var count: Int }
  enum Action { case incrementButtonTapped, incrementLaterTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .incrementButtonTapped:
        state.$count.withLock { $0 += 1 }                 // ① 리듀서에서
        return .none
      case .incrementLaterTapped:
        return .run { [sharedCount = state.$count] _ in   // ② 이펙트가 참조를 캡처
          sharedCount.withLock { $0 += 1 }
        }
      }
    }
  }
}

@MainActor
func testSharedCounter() async {
  let store = TestStore(initialState: SharedCounter.State(count: Shared(value: 0))) {
    SharedCounter()
  }
  await store.send(.incrementButtonTapped) {
    $0.$count.withLock { $0 = 1 }
  }
  await store.send(.incrementLaterTapped)   // 액션으로는 변화가 안 보인다
  store.assert {
    $0.$count.withLock { $0 = 2 }           // 빠뜨리면 테스트 실패
  }
  await store.finish()                      // 단언을 마친 뒤에 이펙트 종료 확인
}

@Reducer
struct TapFeature {
  @ObservableState
  struct State: Equatable { @Shared(value: false) var isOn }
  enum Action { case tap, response }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .tap:
        return .run { send in await send(.response) }
      case .response:
        state.$isOn.withLock { $0.toggle() }
        return .none
      }
    }
  }
}

@MainActor
func testTapFeature() async {
  let store = TestStore(initialState: TapFeature.State()) { TapFeature() }
  await store.send(.tap)                // .tap 자체는 상태를 바꾸지 않는다
  await store.receive(\.response) {
    $0.$isOn.withLock { $0 = true }     // 변경을 만든 액션에서 단언
  }
}

@Reducer
struct StarFeature {
  @ObservableState
  struct State: Equatable { @Shared(.appStorage("stars")) var stars = 0 }
  enum Action { case starTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, _ in
      state.$stars.withLock { $0 += 1 }
      return .none
    }
  }
}

@MainActor
func testStars() async {
  @Shared(.appStorage("stars")) var stars = 41
  $stars.withLock { $0 = 41 }      // 앱 타깃이 먼저 접근했어도 다시 덮는다
  let store = TestStore(initialState: StarFeature.State()) { StarFeature() }
  await store.send(.starTapped) { _ in
    $stars.withLock { $0 = 42 }    // $0 대신 테스트가 잡은 참조로 단언
  }
}

@Reducer
struct TaskSettings {
  @ObservableState
  struct State: Equatable { var isHapticsOn = true }
  enum Action { case toggleTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, _ in
      state.isHapticsOn.toggle()
      return .none
    }
  }
}

@Reducer
struct TaskHome {
  @ObservableState
  struct State: Equatable { var isHapticsOn = true }
  enum Action { case onAppear }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }
  }
}