enum Action {
  case refresh // 更新
  case toggleEditing // 編集モードを切り替える
  case toggleTaskDone(IndexPath) // タスクの完了を切り替える
  case deleteTask(IndexPath) // タスクを削除する
  case moveTask(IndexPath, IndexPath) // タスクを移動する
}

struct State {
  var isEditing: Bool // 編集モードか
  var sections: [TaskListSection] // タスク(モデルデータ)の配列
}

enum Mutation {
  case toggleEditing // 編集モードを切り替える
  case setSections([TaskListSection]) // タスクをセットする
  case insertSectionItem(IndexPath, TaskListSection.Item) // タスクを挿入する
  case updateSectionItem(IndexPath, TaskListSection.Item) // タスクを更新する
  case deleteSectionItem(IndexPath) // タスクを削除する
  case moveSectionItem(IndexPath, IndexPath) // タスクを移動する
}

public typealias _Reactor = Reactor
public protocol Reactor: class, AssociatedObjectStore {
  associatedtype Action
  associatedtype Mutation = Action
  associatedtype State

  /// Viewからのアクション。ユーザが発行するActionをこのSubjectにバインドします。
  /// ActionSubjectはReactorKitが実装しているSubjectで`.next`のみ発行します。
  var action: ActionSubject<Action> { get }

  /// Stateの初期値です。
  var initialState: State { get }

  /// 現在のStateです。ストリームによって変更されます。
  var currentState: State { get }

  /// Stateストリームです。このObservableでStateの変更をObserveできます。
  var state: Observable<State> { get }

  /// Actionのグローバルな変更を行うことができます。このメソッドは他のObservablesとの結合に使用できます。
  /// このメソッドはActionが発行された直後、`mutate(action:)`の直前に呼び出されます。
  func transform(action: Observable<Action>) -> Observable<Action>

  /// ActionからMutationを確定させます。ここでは非同期タスクなど副作用を伴う処理を実行するのに適しています。
  /// このメソッドはActionが発行されるたびに呼び出されます。
  func mutate(action: Action) -> Observable<Mutation>

  /// Mutationのグローバルな変更を行うことができます。このメソッドは他のObservablesとの変換または結合に使用できます。
  /// このメソッドは`mutate(action:)`の直後、`reduce(state:)`の直前に呼び出されます。
  func transform(mutation: Observable<Mutation>) -> Observable<Mutation>

  /// 前回のStateとMutationから新しいStateを生成します。ここでは副作用を起こすべきではありません。
  /// このメソッドはMutationが発行されるたびに呼び出されます。
  func reduce(state: State, mutation: Mutation) -> State

  /// Stateのグローバルな変更を行うことができます。このメソッドでロギングなどの副作用を実行することもできます。
  /// このメソッドは`reduce(state:mutation:)`の直後、新しいStateがcurrentStateに適用される直前に呼び出されます。
  func transform(state: Observable<State>) -> Observable<State>
}

public typealias _View = View
public protocol View: class, AssociatedObjectStore {
  associatedtype Reactor: _Reactor

  /// RxSwiftでおなじみのDisposeBagです。
  /// 注意点として`reactor`が割り当てられるたびに新しく生成されます。
  var disposeBag: DisposeBag { get set }

  /// Viewが使用するReactorです。
  /// このプロパティに新しいReactorが割り当てられると、`bind(reactor:)`が呼び出されます。
  var reactor: Reactor? { get set }

  /// ViewとReactor間の各バインディングを記述するところです。
  /// `reactor`プロパティが割り当てられると呼び出されます。
  /// 注意点として、このメソッドは内部で自動で呼び出されるもので、直接呼び出してはいけません。
  func bind(reactor: Reactor)
}

public protocol StoryboardView: View, _ObjCStoryboardView {
}

// Viewプロトコルに準拠すると`self.reactor`プロパティが利用可能になります。
// CounterViewControllerはStoryboardから生成されますのでStoryboardViewプロトコルに準拠しています。
final class CounterViewController: UIViewController, StoryboardView {
  @IBOutlet var decreaseButton: UIButton!
  @IBOutlet var increaseButton: UIButton!
  @IBOutlet var valueLabel: UILabel!
  @IBOutlet var activityIndicatorView: UIActivityIndicatorView!
  var disposeBag = DisposeBag()

  func bind(reactor: CounterViewReactor) {
    // Action
    increaseButton.rx.tap               // タップイベント
      .map { Reactor.Action.increase }  // タップイベントをAction.increaseに変換
      .bind(to: reactor.action)         // Actionをreactor.actionにバインド
      .disposed(by: disposeBag)

    decreaseButton.rx.tap               // タップイベント
      .map { Reactor.Action.decrease }  // タップイベントをAction.decreaseに変換
      .bind(to: reactor.action)         // Actionをreactor.actionにバインド
      .disposed(by: disposeBag)

    // State
    reactor.state.map { $0.value }      // カウントの値
      .distinctUntilChanged()           // カウントの値に変化があるか
      .map { "\($0)" }                  // カウントの値を文字列に変換
      .bind(to: valueLabel.rx.text)     // カウントの値の文字列をUILabelのtextにバインド
      .disposed(by: disposeBag)

    reactor.state.map { $0.isLoading }  // ロード中か
      .distinctUntilChanged()           // 値に変化があるか
      .bind(to: activityIndicatorView.rx.isAnimating) // ロード中かをUIActivityIndicatorViewのアニメーションにバインド
      .disposed(by: disposeBag)
  }
}

final class CounterViewReactor: Reactor {
  // Viewが行うアクション
  enum Action {
    case increase
    case decrease
  }

  // Actionに対する変更内容
  enum Mutation {
    case increaseValue
    case decreaseValue
    case setLoading(Bool)
  }

  // Viewの状態(具体的な値を保持)
  struct State {
    var value: Int
    var isLoading: Bool
  }

  let initialState: State

  init() {
    self.initialState = State(
      value: 0, // カウントする値の初期値は0
      isLoading: false
    )
  }

  // ActionからMutationを生成する
  func mutate(action: Action) -> Observable<Mutation> {
    switch action {
    case .increase:
      return Observable.concat([
        Observable.just(Mutation.setLoading(true)),
        Observable.just(Mutation.increaseValue).delay(0.5, scheduler: MainScheduler.instance),
        Observable.just(Mutation.setLoading(false)),
      ])

    case .decrease:
      return Observable.concat([
        Observable.just(Mutation.setLoading(true)),
        Observable.just(Mutation.decreaseValue).delay(0.5, scheduler: MainScheduler.instance),
        Observable.just(Mutation.setLoading(false)),
      ])
    }
  }  

  // MutationからStateを更新する
  func reduce(state: State, mutation: Mutation) -> State {
    var state = state
    switch mutation {
    case .increaseValue:
      state.value += 1

    case .decreaseValue:
      state.value -= 1

    case let .setLoading(isLoading):
      state.isLoading = isLoading
    }
    return state
  }
}

struct State {
  var value: Int
  var isLoading: Bool
}

enum Action {
  case increase // 値の増加
  case decrease // 値の減少
}

enum Mutation {
  case increaseValue    // 値の増加
  case decreaseValue    // 値の減少
  case setLoading(Bool) // ロード中か
}

// ActionからMutationを生成する
func mutate(action: Action) -> Observable<Mutation> {
  switch action {
  case .increase:
    return Observable.concat([
      Observable.just(Mutation.setLoading(true)),
      Observable.just(Mutation.increaseValue).delay(0.5, scheduler: MainScheduler.instance),
      Observable.just(Mutation.setLoading(false)),
    ])

  case .decrease:
    return Observable.concat([
      Observable.just(Mutation.setLoading(true)),
      Observable.just(Mutation.decreaseValue).delay(0.5, scheduler: MainScheduler.instance),
      Observable.just(Mutation.setLoading(false)),
    ])
  }
}

// MutationからStateを更新する
func reduce(state: State, mutation: Mutation) -> State {
  var state = state
  switch mutation {
  case .increaseValue:
    state.value += 1

  case .decreaseValue:
    state.value -= 1

  case let .setLoading(isLoading):
    state.isLoading = isLoading
  }
  return state
}

let initialState: State

init() {
  self.initialState = State(
    value: 0, // カウントする値の初期値は0
    isLoading: false
  )
}

increaseButton.rx.tap               // タップイベント
  .map { Reactor.Action.increase }  // タップイベントをAction.increaseに変換
  .bind(to: reactor.action)         // Actionをreactor.actionにバインド
  .disposed(by: disposeBag)

decreaseButton.rx.tap               // タップイベント
  .map { Reactor.Action.decrease }  // タップイベントをAction.decreaseに変換
  .bind(to: reactor.action)         // Actionをreactor.actionにバインド
  .disposed(by: disposeBag) 

reactor.state.map { $0.value }     // カウントの値
  .distinctUntilChanged()          // カウントの値に変化があるか
  .map { "\($0)" }                 // カウントの値を文字列に変換
  .bind(to: valueLabel.rx.text)    // カウントの値の文字列をUILabelのtextにバインド
  .disposed(by: disposeBag)

reactor.state.map { $0.isLoading } // ロード中か
  .distinctUntilChanged()          // 値に変化があるか
  .bind(to: activityIndicatorView.rx.isAnimating) // ロード中かをUIActivityIndicatorViewのアニメーションにバインド
  .disposed(by: disposeBag)

associatedtype Mutation = Action

final class CounterViewReactor: Reactor {
  // Viewが行うアクション
  enum Action {
    case increase
    case decrease
  }

  // Viewの状態(具体的な値を保持)
  struct State {
    var value: Int
  }

  let initialState = State(value: 0) // カウントする値の初期値は0

  // Mutation(Actionと同定義)からStateを更新する
  func reduce(state: State, mutation: Mutation) -> State {
    switch mutation {
    case .increase:
      return State(value: state.value + 1)
    case .decrease:
      return State(value: state.value - 1)
    }
  }
}