// Swift

import Quick
import Nimble
import RxSwift
import RxTest

protocol Alive {}
    
struct Fish: Alive {}
struct Shark: Alive {}
struct Boat {}
    
final class Dolphin {
    var soundEmissions: Observable<String> {
        return encounter.flatMapLatest { thing -> Observable<String> in
            switch thing {
            case is Fish:
                return .just("click")
            case is Alive:
                return .just("whistle")
            default:
                return .empty()
            }
        }
    }
    
    var encounter = PublishSubject<Any>()
}

final class FactionSelectionViewModelTests: QuickSpec {
    override func spec() {
        
        describe("a reactive 🐬") {
            var dolphin: Dolphin!
            var testScheduler: TestScheduler!
            var disposeBag: DisposeBag!
            
            beforeEach {
                dolphin = Dolphin()
                testScheduler = TestScheduler(initialClock: 0)
                disposeBag = DisposeBag()
            }
            
            describe("encountering") {
                var encounters: [Recorded<Event<Any>>]!
                
                context("with a series of things") {
                    beforeEach {
                        encounters = [
                            .next(100, Boat()),
                            .next(200, Fish()),
                            .next(300, Fish()),
                            .next(400, Shark()),
                            .next(500, Boat()),
                            .completed(600)
                        ]
                    }
                    
                    it("emits sounds accordingly") {
                        let observer = testScheduler.createObserver(String.self)
                        
                        testScheduler
                            .createHotObservable(encounters)
                            .bind(to: dolphin.encounter)
                            .disposed(by: disposeBag)
                        
                        dolphin
                            .soundEmissions
                            .bind(to: observer)
                            .disposed(by: disposeBag)
                        
                        // Yeah let's just expect these sounds
                        let expected = ["click", "click", "whistle"]
                        
                        testScheduler.start()
                        
                        // Uhh, let's just assume checking the returned strings is enough.
                        // Also just hide those pesky nils. (If you are vigilant enough you 
                        // see that the below compact map is intended to filter out one extra 
                        // nil emission from the .completed event.)
                        expect(observer.events.compactMap { $0.value.element }).to(equal(expected))
                    }
                }
            }
        }
	}
}

// Same as above

                    it("emits sounds accordingly") {
                        let observer = testScheduler.createObserver(String.self)
                        
                        testScheduler
                            .createHotObservable(encounters)
                            .bind(to: dolphin.encounter)
                            .disposed(by: disposeBag)
                        
                        dolphin
                            .soundEmissions
                            .bind(to: observer)
                            .disposed(by: disposeBag)
                        
                        let expected: [Recorded<Event<String>>] = [
                            .next(200, "click"),
                            .next(300, "click"),
                            .next(400, "whistle"),
                            .completed(600)
                        ]
                        
                        testScheduler.start()
                        
                        expect(observer.events).to(equal(expected))
                    }
                    
// Same as above