/// 현재 Presentable이 보여지고 있으면
/// 불리언 값으로 트리거하는 옵저버블입니다
var rxVisible: Observable<Bool> { get }

/// 이 presentable이 화면에 처음으로 그려지면
/// 딱 한 번 트리거됩니다
var rxFirstTimeVisible: Single<Void> { get }

/// presentable이 사라지면 딱 한 번 트리거됩니다
var rxDismissed: Single<Void> { get }

extension Reactive where Base: UIViewController {

    /// 뷰가 처음으로 나타나면 트리거됩니다
    public var firstTimeViewDidAppear: Single<Void> {
        return sentMessage(#selector(Base.viewDidAppear)).map { _ in
            return Void()
        }.take(1).asSingle()
    }

    /// 뷰가 사라지면 트리거됩니다
    public var dismissed: ControlEvent<Bool> {
        let source = sentMessage(#selector(Base.dismiss))
                     .map { $0.first as? Bool ?? false }
        return ControlEvent(events: source)
    }

    /// 뷰의 상태가 변경되면 트리거됩니다
    public var displayed: Observable<Bool> {
        let viewDidAppearObs = sentMessage(#selector(Base.viewDidAppear))
                               .map { _ in true }
        let viewWillDisappearObs = sentMessage(#selector(Base.viewWillDisappear))
                                   .map { _ in false }
        return Observable<Bool>.merge(viewDidAppearObs, viewWillDisappearObs)
    }
}

nextPresentable.rxFirstTimeVisible.subscribe(onSuccess: { [unowned self,
                                                           unowned nextPresentable,
                                                           unowned nextStepper] (_) in
    // presentable의 Stepper를 듣습니다
    // 새로운 Step 값마다 우리는 새로운 네비게이션 프로세스를 트리거합니다
    // 이것은 RxFlow 전체 매커니즘의 핵심 규칙입니다
    // 이 처리 과정은 presentable이 화면에서 사라질때마다 멈춥니다
    // 예를 들어 다른 presentable이 그것의 위에 있을 경우의 ViewController의 계층처럼요
    nextStepper.steps
        .pausable(nextPresentable.rxVisible.startWith(true))
        .asDriver(onErrorJustReturn: NoStep())
        .drive(onNext: { [unowned self] (step) in
            // the nextPresentable's Stepper fires a new Step
            self.steps.onNext(step)
        }).disposed(by: nextPresentable.disposeBag)

}).disposed(by: self.disposeBag)

extension ObservableType {

    /// 두 번째 옵저버블 시퀀스의 마지막 요소를 기반으로
    /// 원본 옵저버블 시퀀스의 요소를 멈춥니다.
    /// 두 번째 시퀀스의 가장 최근 발생한 값이
    /// `true` 가아닐때까지 요소는 무시됩니다.
    /// - Parameter Pauser: 원본 옵저버블 시퀀스를 멈추는데에 쓰이는 옵저버블 시퀀스입니다.
    /// - Returns: pauser 옵저버블 시퀀스에 기반해서 멈춘 옵저버블 시퀀스입니다.
    public func pausable<P: ObservableType> ( _ pauser: P) -> Observable<E>
                                                              where P.E == Bool {
        return withLatestFrom(pauser) { element, paused in
            (element, paused)
            }.filter { _, paused in
                paused
            }.map { element, _ in
                element
        }
    }
}

nextStepper
    .steps
    .pausable(nextPresentable.rxVisible.startWith(true))
    .asDriver(onErrorJustReturn: NoStep())
    .drive(onNext: { [unowned self] (step) in
        // nextPresentable의 Stepper가 새로운 Step을 생성합니다
        self.steps.onNext(step)
    }).disposed(by: nextPresentable.disposeBag)

private var subjectContext: UInt8 = 0

/// Stepper에겐 오직 하나의 목적만이 있습니다.
/// 특정한 네비게이션 상태에 대응하는 Step을 발생시키는 것입니다.
/// 특정 Flow의 컨텍스트에선 상태 변경이 네비게이션 액션으로 이어지기도 합니다.
public protocol Stepper: Synchronizable {

    /// Rx Observable이 새로운 Step을 트리거할 것입니다.
    var steps: Observable<Step> { get }
}

public extension Stepper {
    /// 새로운 Step을 발행할 step
    public var step: BehaviorSubject<Step> {
        return self.synchronized {
            if let subject = objc_getAssociatedObject(self, &subjectContext)
                             as? BehaviorSubject<Step> {
                return subject
            }
            let newSubject = BehaviorSubject<Step>(value: NoStep())
            objc_setAssociatedObject(self,
                                     &subjectContext,
                                     newSubject,
                                     .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            return newSubject
        }
    }

    /// 새로운 Step을 트리거할 Rx Observable
    public var steps: Observable<Step> {
        return self.step.asObservable()
    }
}