import RxSwift

extension PrimitiveSequence where Trait == CompletableTrait, Element == Never {
    public func asMaybe() -> Maybe<Never> {
        return Maybe.create { maybe in
            return self.subscribe(
                onCompleted: { maybe(.completed) },
                onError: { error in maybe(.error(error)) })
        }
    }
}

extension PrimitiveSequence where Trait == MaybeTrait {
    public func asSingle() -> Single<Element> {
        return Single.create { single in
            return self.subscribe(
                onSuccess: { element in single(.success(element)) },
                onError: { error in single(.error(error)) },
                onCompleted: { single(.error(RxError.noElements)) })
        }
    }

    public func asCompletable() -> Completable {
        return Completable.create { completable in
            return self.subscribe(
                onSuccess: { _ in completable(.completed) },
                onError: { error in completable(.error(error)) },
                onCompleted: { completable(.completed) })
        }
    }

    public func flatMapCompletable(selector: @escaping (Element) throws -> Completable) -> Completable {
        return self.flatMap { try selector($0).asMaybe() }.asCompletable()
    }
    
    public func ifEmpty(switchTo other: Maybe<Element>) -> Maybe<Element> {
        return asObservable().ifEmpty(switchTo: other.asObservable()).asMaybe()
    }
    
    public func ifEmpty(default: Element) -> Maybe<Element> {
        return asObservable().ifEmpty(default: `default`).asMaybe()
    }

    public var isEmpty: Single<Bool> {
        let disposeBag = DisposeBag()
        var result = Single.just(true)
        asObservable()
            .map({ (value) in
                result = Single.just(false)
            })
            .subscribe()
            .addDisposableTo(disposeBag)
        return result
    }
}

extension PrimitiveSequence where Trait == SingleTrait {
    public func asMaybe() -> Maybe<Element> {
        return Maybe.create { maybe in
            return self.subscribe(
                onSuccess: { element in maybe(.success(element)) },
                onError: { error in maybe(.error(error)) })
        }
    }

    public func asCompletable() -> Completable {
        return Completable.create { completable in
            return self.subscribe(
                onSuccess: { _ in completable(.completed) },
                onError: { error in completable(.error(error)) })
        }
    }
    
    public func compose<T>(_ block: ((Single<Element>) -> Single<T>)) -> Single<T> {
        return block(self)
    }

    public func flatMapCompletable(selector: @escaping (Element) throws -> Completable) -> Completable {
        return self.asMaybe().flatMap { try selector($0).asMaybe() }.asCompletable()
    }

    public func asOptional() -> Element? {
        var result: Element? = nil
        let disposeBag = DisposeBag()
        asObservable()
            .map { (value) in
                result = value
            }
            .subscribe()
            .addDisposableTo(disposeBag)
        return result
    }
}

extension Observable {
    public func compose<T>(_ block: ((Observable<E>) -> Observable<T>)) -> Observable<T> {
        return block(self)
    }
}