struct Single<Element> {
	let source: Observable<Element>
}

struct Driver<Element> {
	let source: Observable<Element>
}

func getRepo(_ repo: String) -> Single<[String: Any]> {
	return Single<[String: Any]>.create { single in
		let task = URLSession.dataTask(with: URL(string: "https://api.github.com/\(repo)")! { data, _, error in
			if let error {
				single(.failure(error))
				return
			}

			guard let data,
				let json = try? JSONSerialization.jsonObject(with: data, option: .mutableLeaves),
				let result = json as? [String: Any] else {
					single(.failure(DataError.cantParseJSON))
					return	  
			}

			single(.success(result))
		}
		task.resume()

		return Disposables.create { task.cancel() }
	}
}

getRepo("ReactiveX/RxSwift")
	.subscribe(onSuccess: { json in
			print("JSON: ", json)
		},
		onError: { error in
			print("Error: ", error)
		})
	.disposed(by: self.disposeBag)

func cacheLocally() -> Completable {
	return Completable.create { completable in
		guard success else {
			completable(.error(CacheError.failedCaching))
			return Disposables.create { }
		}

		completable(.completed)
		return Disposables.create { }
	}
}

cacheLocally()
	.subscribe(onCompleted: {
		print("Completed with no error.")
	},
	onError: { error in
		print("Completed with an error: \(error.localizedDescription)")
	})
	.disposed(by: self.disposebag)

func generateString() -> Maybe<String> {
	return Maybe<String>.create { maybe in
		maybe(.success("RxSwift"))
		// or
		maybe(.completed)
		// or
		maybe(.error(error))

		return Disposables.create { }
	}
}

generateString()
	.subscribe(onSuccess: { element in
		print("Completed with element \(element)")
	},
	.onError { error in
		print("Completed with an error \(error.localizedDescription)")
	},
	onCompleted: {
		print("Completed with no element")
	})
	.disposed(by: self.disposeBag)

let results = query.rx.text
	.throttle(.milliseconds(300), scheduler: MainScheduler.instance)
	.flatMapLatest { query in
		fetchAutoCompleteItems(query)
	}

results
	.map { "\($0.count)" }
	.bind(to: resultCount.rx.text)
	.disposed(by: self.disposeBag)

results
	.bind(to: resultsTableView.rx.items(cellIdentifier: "Cell")) { _, result, cell in
		cell.textLabel?.text = "\(result)"
	}
	.disposed(by: self.disposeBag)

let results = query.rx.text
	.throttle(.milliseconds(300), scheduler: MainScheduler.instance)
	.flatMapLatest { query in
		fetchAutoCompleteItems(query)
			.observeOn(MainScheduler.instance)
			.catchErrorJustReturn([])
	}
	.share(replay: 1)

let results = query.rx.text.asDriver()
	.throttle(.milliseconds(300), scheduler: MainScheduler.instance)
	.flatMapLatest { query in
		fetchAutoCompleteItems(query)
			.asDriver(onErrorJustReturn: [])
	}

results
	.map { "\($0.count)" }
	.drive(resultCount.rx.text)
	.disposed(by: self.disposeBag)

results
	.drive(resultsTableView.rx.items(cellIdentifier: "Cell")) { _, result, cell in
		cell.textLabel?.text = "\(result)"
	}
	.disposed(by: self.disposeBag)

let safeSequence = xs
	.observeOn(MainScheduler.instance)
	.catchErrorJustReturn(onErrorJustReturn)
	.share(replay: 1, scope: .whileConnected)
return Driver(raw: safeSequence)

extension Reactive where Base: UISearchBar {
	public var value: ControlProperty<String?> {
		let source: Observable<String?> = Observable.deferred { [weak searchBar = self.base as UISearchBar] () -> Observable<String?> in
			let text = searchBar?.text
			return (searchBar?.rx.delegate.methodInvoked(#selector(UISearchBarDelegate.searchBar(_:textDidChange:))) ?? Observable.empty())
				.map { a in
					return a[1] as? String
				}
				.startWith(text)
		}

		let bindingObserver = Binder(self.base) { (searchBar, text: String?) in
			searchBar.text = text
		}

		return ControlProperty(values: source, valueSink: bindingObserver)
	}
}

extension Reactive where Base: UICollectionView {
	public var itemSelected: ControlEvent<IndexPath> {
		let source = delegate.methodInvoked(#selector(UICollectionViewDelegate.collectionView(_:didSelectItemAt:)))
			.map { a in
				return a[1] as! IndexPath
			}

		return ControlEvent(events: source)
	}
}