open class BaseTestCase: XCTestCase {
    /// 초기에 주입받아야 할 데이터를 지정합니다
    open func given(_ task: () -> Void) {
        task()
    }

    /// 발생해야 할 이벤트, 또는 메소드 호출등을 실행시킵니다
    open func when(_ task: () -> Void) {
        task()
    }

    /// 결과 값이 기대와 같은지 확인합니다
    open func then(_ task: () -> Void) {
        task()
    }
}

/// Rx로 만들어진 이벤트 스트림을 테스트하는 테스트케이스
open class RxTestCase<T>: BaseTestCase {
    open var scheduler: TestScheduler!
    open var disposeBag: DisposeBag!
    private var resultObserver: TestableObserver<T>!

    /// 이 TestCase에서 관측하고자 하는 대상을 설정합니다.
    open var eventsToObserve: Observable<T> = .empty() {
        didSet {
            disposeBag = DisposeBag()
            scheduler = TestScheduler(initialClock: 0)
            resultObserver = scheduler.createObserver(T.self)
            eventsToObserve.bind(to: resultObserver).disposed(by: disposeBag)
        }
    }

    open func when(observing events: Observable<T>, _ task: () -> Void) {
        self.eventsToObserve = events
        task()
        executeEvents()
    }

    // 이 테스트에서 처리해야 할 입력을 편하게 생성하도록 합니다.
    open func createEvents<U>(_ events: [Recorded<Event<U>>], to relay: PublishRelay<U>) {
        scheduler.createHotObservable(events)
            .bind(to: relay)
            .disposed(by: disposeBag)
    }

    open func createEvents<U>(_ events: [Recorded<Event<U>>], to subject: PublishSubject<U>) {
        scheduler.createHotObservable(events)
            .bind(to: subject)
            .disposed(by: disposeBag)
    }

    open func executeEvents(advanceTo futureTime: VirtualTimeScheduler<TestSchedulerVirtualTimeConverter>.VirtualTime = 10) {
        scheduler.start()
        scheduler.advanceTo(futureTime)
        scheduler.stop()
    }

    /// 테스트의 결과. 테스트의 마지막에는 , 이 값에 기대한 값이 들어있는지 확인한다.
    open var resultEvents: [Recorded<Event<T>>] {
        resultObserver.events
    }
}

class SampleRxTestCase: RxTestCase<String> {

    func test버튼하나만_누르면_동작_안함() {
        given {
            viewModel = SampleViewModel(data: "Hello")
        }

        when(observing: viewModel.log) {
            createEvents([.next(0, Void())], to: viewModel.aButtonClicked)
        }

        then {
            XCTAssert(resultEvents.isEmpty)
        }
    }

    func test버튼_두개를_눌러야_동작함() {
        given {
            viewModel = SampleViewModel(data: "World")
        }

        when(observing: viewModel.log) {
            createEvents([.next(0, Void())], to: viewModel.aButtonClicked)
            createEvents([.next(1, Void())], to: viewModel.bButtonClicked)
        }

        then {
            XCTAssert(resultEvents == [.next(1, "World")])
        }
    }
} 

open class EventLoggingTestCase: RxTestCase<(name: String, properties: [String: Any]?)> {
    open override func setUpWithError() throws {
        try super.setUpWithError()
        EventLogger.eventObserver = PublishSubject<(name: String, properties: [String: Any]?)>()
    }

    open override func when(_ task: () -> Void) {
        eventsToObserve = EventLogger.eventObserver
        task()
        executeEvents()
    }
}

open class PresentableLogicTestCase: RxTestCase<Presentable> {
    open var resultPresentableEvents: [Recorded<Event<String?>>] {
        resultEvents.map { event in
            guard let element = event.value.element,
                let description = (element as? CustomDebugStringConvertible)?.debugDescription else {
                return Recorded<Event<String?>>.next(event.time, nil)
            }
            return Recorded<Event<String?>>.next(event.time, description)
        }
    }
}

extension PresentableView: CustomDebugStringConvertible {
    public var debugDescription: String {
        switch self {
        case let .cardSectionDetail(section):
            return "cardSectionDetail for section.\(section.id)"
        }
    }
}

class SamplePushableTestCase: PushableLogicTestCase {

    func test이름입력하고_제출버튼_누르면_디테일화면_푸시() {
        given {
            viewModel = SampleViewModel(data: "Hello")
        }

        when {
            createEvents([.next(0, "MyName")], to: viewModel.textEdited)
            createEvents([.next(0, Void())], to: viewModel.submitButtonClicked)
        }

        then {
            XCTAssert(resultPushableEvents == [.next(0, "detailView titled Hello")])
        }
    }

    func test이름입력_안하고_제출버튼_누르면_화면이동_안_함() {
        given {
            viewModel = SampleViewModel(data: "Hello")
        }

        when {
            createEvents([.next(0, Void())], to: viewModel.submitButtonClicked)
        }

        then {
            XCTAssert(resultPushableEvents.isEmpty)
        }
    }
}