01 · 아키텍처 선택 이유

// ❌ Action → State 로 직결하면, 비동기 결과를 넣을 자리가 없다
func reduce(state: State, action: Action) -> State {
    switch action {
    case .refresh:
        // 여기서 API를 호출하면? → reduce가 더 이상 순수 함수가 아니다
        // 호출 안 하면?        → 로딩 시작만 반영하고 결과는 반영할 길이 없다
        return state
    }
}

// ✅ 두 단계로 쪼개면 둘 다 해결된다
//    mutate : 비동기를 다루고, "상태 변화 여러 개"를 스트림으로 내보낸다
//    reduce : 그 변화 하나를 받아 새 상태를 만든다 (동기·순수)

import ReactorKit
import RxSwift

final class SearchViewReactor: Reactor {

    // ① 사용자 의도
    enum Action {
        case updateQuery(String)
        case search
        case clear
    }

    // ② 상태 변화의 최소 단위 — Action과 1:1이 아니다
    enum Mutation {
        case setQuery(String)
        case setLoading(Bool)
        case setItems([Item])
        case setError(String)
        case reset
    }

    // ③ 화면이 그릴 수 있는 전부
    struct State {
        var query: String = ""
        var isLoading: Bool = false
        var items: [Item] = []
        @Pulse var errorMessage: String?     // 같은 값이어도 매번 이벤트를 받고 싶을 때
    }

    let initialState = State()
    private let searchService: SearchServiceType

    init(searchService: SearchServiceType) {   // 의존성은 생성자 주입
        self.searchService = searchService
    }

    // ④ 부수효과 — 여기서만
    func mutate(action: Action) -> Observable<Mutation> {
        switch action {
        case let .updateQuery(query):
            return .just(.setQuery(query))       // 동기 변화도 Mutation 하나

        case .search:
            // ★ Action 하나 → Mutation 셋. 이게 2단계 분리의 존재 이유다
            let query = currentState.query       // 진입 시점 값을 붙잡는다
            return Observable.concat([
                .just(.setLoading(true)),
                searchService.search(query)
                    .observe(on: MainScheduler.instance)
                    .map(Mutation.setItems)
                    .catch { .just(.setError($0.localizedDescription)) },
                .just(.setLoading(false))
            ])

        case .clear:
            return .just(.reset)
        }
    }

    // ⑤ 상태 전이 — 순수 함수. 효과 절대 금지
    func reduce(state: State, mutation: Mutation) -> State {
        var newState = state
        switch mutation {
        case let .setQuery(query):   newState.query = query
        case let .setLoading(flag):  newState.isLoading = flag
        case let .setItems(items):   newState.items = items
        case let .setError(message): newState.errorMessage = message
        case .reset:                 newState = State()
        }
        return newState
    }
}

final class SearchViewController: UIViewController, ReactorView {
    var disposeBag = DisposeBag()

    func bind(reactor: SearchViewReactor) {
        // Action (View → Reactor)
        searchBar.rx.text.orEmpty
            .map { Reactor.Action.updateQuery($0) }
            .bind(to: reactor.action)
            .disposed(by: disposeBag)

        searchButton.rx.tap
            .map { Reactor.Action.search }
            .bind(to: reactor.action)
            .disposed(by: disposeBag)

        // State (Reactor → View)
        reactor.state.map(\.items)
            .distinctUntilChanged()                  // 중복 렌더 방지
            .bind(to: tableView.rx.items(cellIdentifier: "cell")) { _, item, cell in
                cell.textLabel?.text = item.title
            }
            .disposed(by: disposeBag)

        reactor.state.map(\.isLoading)
            .distinctUntilChanged()
            .bind(to: indicator.rx.isAnimating)
            .disposed(by: disposeBag)

        // @Pulse — 같은 에러 메시지가 두 번 와도 두 번 다 뜬다
        reactor.pulse(\.$errorMessage)
            .compactMap { $0 }
            .subscribe(onNext: { [weak self] in self?.showAlert($0) })
            .disposed(by: disposeBag)
    }
}

// 주입은 바깥에서
let vc = SearchViewController()
vc.reactor = SearchViewReactor(searchService: searchService)

let action    = ActionSubject<Action>()                  // 진입점
let mutation  = transform(action: action.asObservable())  // ① 액션 가공
                  .flatMap { self.mutate(action: $0) }    // ② 부수효과 실행
let piped     = transform(mutation: mutation)             // ③ 전역 스트림 합류
let state     = piped
                  .scan(initialState) { state, mutation in    // ④ ★ 여기가 핵심
                      self.reduce(state: state, mutation: mutation)
                  }
                  .startWith(initialState)
                  .share(replay: 1)                           // 늦게 구독해도 최신 상태

// ★ scan 이 전부다.
//   State 스트림은 "Mutation 스트림에 reduce를 누적 적용한 것"이다.
//   현재 상태를 어딘가 저장해 두는 게 아니라, 초기 상태부터 접어 온 결과다.

// ① 최종 상태만 보면 되는 경우
func testClear() {
    let reactor = SearchViewReactor(searchService: StubSearchService())
    reactor.action.onNext(.updateQuery("swift"))
    XCTAssertEqual(reactor.currentState.query, "swift")

    reactor.action.onNext(.clear)
    XCTAssertEqual(reactor.currentState.query, "")
}

// ② 중간 상태(isLoading: false → true → false)까지 봐야 하는 경우
//    currentState로는 못 잡는다. TestScheduler로 시간축을 만든다.
func testLoadingSequence() {
    let scheduler = TestScheduler(initialClock: 0)
    let reactor = SearchViewReactor(searchService: StubSearchService())
    let disposeBag = DisposeBag()

    scheduler.createHotObservable([.next(100, SearchViewReactor.Action.search)])
        .subscribe(reactor.action)
        .disposed(by: disposeBag)

    let response = scheduler.start(created: 0, subscribed: 0, disposed: 1000) {
        reactor.state.map(\.isLoading)
    }
    XCTAssertEqual(response.events.map(\.value.element), [
        false,  // 초기 상태
        true,   // .search 직후
        false   // 완료 후
    ])
}

밀리 머신 = (Q, Σ, Λ, δ, λ, q₀)
    Q  상태 집합       Σ  입력 알파벳      Λ  출력 알파벳
    δ : Q × Σ → Q     전이 함수 (다음 상태)
    λ : Q × Σ → Λ     출력 함수 (부수적으로 내보내는 것)

// TCA — 두 함수를 한 메서드에 합쳐 놓는다
Reduce { state, action in
    state.x = 1              // δ 역할
    return .run { ... }      // λ 역할 (Effect)
}

// ReactorKit — 두 함수를 서로 다른 메서드로 분리한다
func mutate(action: Action) -> Observable      // λ 에 해당 (효과·출력)
func reduce(state: State, mutation: Mutation) -> State   // δ 에 해당 (순수 전이)

// ★ 그래서 ReactorKit의 reduce는 교과서적 δ 그 자체다.
//   반환 타입에 Effect가 섞여 있지 않다 — 순수성이 시그니처로 강제된다.

// 리스트에 대한 fold — 결과 하나
[m1, m2, m3].reduce(s0, reduce)  ==  reduce(reduce(reduce(s0, m1), m2), m3)

// 스트림에 대한 scan — 중간 결과를 전부 방출
mutations.scan(s0, accumulator: reduce)
   방출: s1 = reduce(s0, m1)
        s2 = reduce(s1, m2)
        s3 = reduce(s2, m3)   …

// 그래서 상태는 "저장된 것"이 아니라 "접어 온 것"이다.
//   sn = fold(reduce, s0, [m1 … mn])
//
// 여기서 두 가지가 따라 나온다:
//   ① 초기 상태 + Mutation 로그만 있으면 어느 시점이든 재구성된다 → 이벤트 소싱
//   ② reduce가 순수해야만 이 재구성이 성립한다 → 순수성은 편의가 아니라 전제

State0 ──m1──▶ State1 ──m2──▶ State2 ── … ──mn──▶ Staten

// reduce가 순수(참조 투명)하므로:
//   Staten = fold(reduce, State0, [m1 … mn])
//
// → 초기 상태 + Mutation 시퀀스만 있으면 어떤 시점의 화면이든 되살릴 수 있다.
// → QA는 "스크린샷"이 아니라 "Action/Mutation 로그"를 보내면 된다.
//
// 중요한 건 이 성질이 ReactorKit의 기능이 아니라 순수 함수의 수학적 귀결이라는 것.
// "ReactorKit이라서 재현된다"가 아니라
// "전이 함수를 순수하게 유지했기 때문에 재현된다"가 정확한 인과다.

func transform(mutation: Observable<Mutation>) -> Observable<Mutation> {
    mutation.do(onNext: { Logger.log("MUTATION \($0)") })
}
func transform(state: Observable<State>) -> Observable<State> {
    state.do(onNext: { Logger.log("STATE \($0)") })
}
// 파이프라인 한 곳에만 붙이면 그 화면의 모든 상태 전이가 기록된다.
// 이게 "단방향이라 추적 가능하다"의 구체적 의미다.

// ❌ 표현 가능한 조합 2×2×2 = 8, 유효한 건 4
struct BadState {
    var isLoading: Bool
    var error: String?
    var items: [Item]
}
// "로딩 중인데 에러도 있고 아이템도 있는" 상태를 코드로 만들 수 있다

// ✅ 상태 공간 자체를 잘라낸다
struct GoodState {
    var query: String = ""
    var phase: Phase = .idle
    enum Phase { case idle, loading, loaded([Item]), failed(String) }
}
// 정확히 4가지. 무효 상태가 존재하지 않는다.
// 이건 ReactorKit의 기능이 아니라 State를 값 타입 하나로 모았기에 가능한 설계다.