Day 4 · 바인딩

@Observable
final class SettingsModel {
  var isHapticsEnabled = true
}

struct SettingsScreen: View {
  @Bindable var model: SettingsModel
  var body: some View {
    Toggle("햅틱", isOn: $model.isHapticsEnabled)
  }
}

struct HapticsView: View {
  @Bindable var store: StoreOf<Haptics>   // Action이 BindableAction이 아니다
  var body: some View {
    Toggle("햅틱", isOn: $store.isHapticsEnabled)
    // error: cannot assign through dynamic lookup property: subscript is get-only
  }
}

@Reducer
struct Haptics {
  @ObservableState
  struct State: Equatable {
    var isHapticsEnabled = true
  }
  enum Action {
    case isHapticsEnabledChanged(Bool)
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .isHapticsEnabledChanged(isOn):
        state.isHapticsEnabled = isOn
        return .none
      }
    }
  }
}

struct HapticsToggleView: View {
  @Bindable var store: StoreOf<Haptics>   // $store를 쓰려면 @Bindable
  var body: some View {
    Toggle(
      "햅틱",
      isOn: $store.isHapticsEnabled.sending(\.isHapticsEnabledChanged)
    )
  }
}

enum Digest: String, CaseIterable, Hashable {
  case daily, weekly, off
}

@Reducer
struct ProfileSettings {
  @ObservableState
  struct State: Equatable {
    var digest = Digest.daily
    var displayName = ""
    var enableNotifications = false
    var protectMyPosts = false
  }
  enum Action: BindableAction {                 // ①
    case binding(BindingAction<State>)
  }

  var body: some ReducerOf<Self> {
    BindingReducer()                            // ②
  }
}

struct ProfileSettingsView: View {
  @Bindable var store: StoreOf<ProfileSettings>
  var body: some View {
    Form {                                      // ③
      TextField("표시 이름", text: $store.displayName)
      Toggle("알림", isOn: $store.enableNotifications)
      Toggle("내 글 보호", isOn: $store.protectMyPosts)
      Picker("요약 메일", selection: $store.digest) {
        ForEach(Digest.allCases, id: \.self) { Text($0.rawValue) }
      }
    }
  }
}

var body: some ReducerOf<Self> {
  Reduce { state, action in
    switch action {
    case .binding:
      return .none          // 아무도 state에 대입하지 않는다
    }
  }
}
// DEBUG 런타임 경고:
// A binding action sent from a store was not handled. ...
// To fix this, invoke "BindingReducer()" from your feature reducer's "body".

@Reducer
struct SliderForm {
  @ObservableState
  struct State: Equatable {
    var sliderValue = 5.0
    var stepCount = 10
  }
  enum Action: BindableAction {
    case binding(BindingAction<State>)
    case resetButtonTapped
  }

  var body: some ReducerOf<Self> {
    BindingReducer()                 // 먼저 대입
    Reduce { state, action in        // 그다음 보정
      switch action {
      case .binding(\.stepCount):
        state.sliderValue = min(state.sliderValue, Double(state.stepCount))
        return .none
      case .binding:
        return .none
      case .resetButtonTapped:
        state = State()
        return .none
      }
    }
  }
}

@Reducer
struct NicknameForm {
  @ObservableState
  struct State: Equatable {
    var nickname = ""
    var isNicknameValid = false
  }
  enum Action: BindableAction {
    case binding(BindingAction<State>)
  }

  var body: some ReducerOf<Self> {
    BindingReducer()
      .onChange(of: \.nickname) { oldValue, state in
        state.isNicknameValid = (2...12).contains(state.nickname.count)
        return .none                     // 필요하면 .run { … }도 가능
      }
  }
}

struct SignInScreen: View {
  enum Field: Hashable { case username, password }
  @State private var username = ""
  @State private var password = ""
  @FocusState private var focusedField: Field?

  var body: some View {
    Form {
      TextField("아이디", text: $username)
        .focused($focusedField, equals: .username)
      SecureField("비밀번호", text: $password)
        .focused($focusedField, equals: .password)
      Button("로그인") {
        if username.isEmpty { focusedField = .username }
        else if password.isEmpty { focusedField = .password }
      }
    }
  }
}

@Reducer
struct SignIn {
  @ObservableState
  struct State: Equatable {
    var focusedField: Field?
    var password = ""
    var username = ""

    enum Field: Hashable {
      case username, password
    }
  }
  enum Action: BindableAction {
    case binding(BindingAction<State>)
    case signInButtonTapped
  }

  var body: some ReducerOf<Self> {
    BindingReducer()
    Reduce { state, action in
      switch action {
      case .binding:
        return .none
      case .signInButtonTapped:
        if state.username.isEmpty {
          state.focusedField = .username
        } else if state.password.isEmpty {
          state.focusedField = .password
        }
        return .none
      }
    }
  }
}

struct SignInView: View {
  @Bindable var store: StoreOf<SignIn>
  @FocusState var focusedField: SignIn.State.Field?

  var body: some View {
    Form {
      TextField("아이디", text: $store.username)
        .focused($focusedField, equals: .username)
      SecureField("비밀번호", text: $store.password)
        .focused($focusedField, equals: .password)
      Button("로그인") { store.send(.signInButtonTapped) }
    }
    .bind($store.focusedField, to: $focusedField)   // 양방향 동기화
  }
}

import Testing

@MainActor
@Test func signInFocusTest() async {
  let store = TestStore(initialState: SignIn.State()) {
    SignIn()
  }
  await store.send(\.binding.username, "blob") {
    $0.username = "blob"
  }
  await store.send(.signInButtonTapped) {
    $0.focusedField = .password        // 비밀번호가 비었으니 그쪽으로
  }
}

@Reducer
struct SignUp {
  @ObservableState
  struct State: Equatable {
    var email = ""
    var password = ""
    var agreesToTerms = false
    var isPasswordLong = false
  }
  enum Action {
    case signUpButtonTapped
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .signUpButtonTapped:
        // TODO: 빈 칸으로 포커스
        return .none
      }
    }
  }
}

struct SignUpView: View {
  let store: StoreOf<SignUp>
  var body: some View {
    Form {
      Text(store.email)   // TODO: TextField · SecureField · Toggle로 바꾸기
      Button("가입") { store.send(.signUpButtonTapped) }
        .disabled(!store.agreesToTerms)
    }
  }
}

#Preview {
  SignUpView(store: Store(initialState: SignUp.State()) { SignUp() })
}