extension Reactive where Base: URLSession {
  // ...
}

extension Reactive where Base: URLSession {
    func response(request: URLRequest) ->
    Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            // content goes here
            return Disposables.create()
        }
    }
}

extension Reactive where Base: URLSession {
    func response(request: URLRequest) ->
    Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { data, response, error in
                // ...
            }
            task.resume()
            return Disposables.create()
        }
    }
}

extension Reactive where Base: URLSession {
    func response(request: URLRequest) ->
    Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { data, response, error in
                // ...
            }
            task.resume()
            return Disposables.create { task.cancel() }
        }
    }
}

extension Reactive where Base: URLSession {
    func response(request: URLRequest) ->
    Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { data, response, error in
               guard let response = response, let data = data else {
                    observer.onError(error ?? RxURLSessionError.unknown)
                    return
                }
                guard let httpResponse = response as? HTTPURLResponse else {
                    observer.onError(RxURLSessionError.invalidResponse(response: response))
                    return
                }
                observer.onNext((httpResponse, data))
                observer.onCompleted()
            }
            task.resume()
            return Disposables.create { task.cancel() }
        }
    }
}

extension Reactive where Base: URLSession {
    func response(request: URLRequest) ->
    Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { data, response, error in
                guard let response = response, let data = data else {
                    observer.onError(error ?? RxURLSessionError.unknown)
                    return
                }
                guard let httpResponse = response as? HTTPURLResponse else {
                    observer.onError(RxURLSessionError.invalidResponse(response: response))
                    return
                }
                observer.onNext((httpResponse, data))
                observer.onCompleted()
            }
            task.resume()
            return Disposables.create { task.cancel() }
        }
    }
    
    func data(request: URLRequest) -> Observable<Data> {
        return response(request: request).map { response, data -> Data in
            guard 200 ..< 300 ~= response.statusCode else {
                throw RxURLSessionError.requestFailed(response: response, data: data)
            }
            return data
        }
    }
    
    func string(request: URLRequest) -> Observable<String> {
        return data(request: request).map { data in
            return String(data: data, encoding: .utf8) ?? ""
        }
    }
    
    func json(request: URLRequest) -> Observable<Any> {
        return data(request: request).map { data in
            return try JSONSerialization.jsonObject(with: data)
        }
    }
    
    func decodable<D: Decodable>(
        request: URLRequest,
        type: D.Type
    ) -> Observable<D> {
        return data(request: request).map { data in
            let decoder = JSONDecoder()
            return try decoder.decode(type, from: data)
        }
    }
    
    func image(request: URLRequest) -> Observable<UIImage> {
        return data(request: request).map { data in
            return UIImage(data: data) ?? UIImage()
        }
    }
}

private var internalCache = [String: Data]()

extension ObservableType where Element == (HTTPURLResponse, Data) {
    func cache() -> Observable<Element> {
        return self.do(onNext: { response, data in
            guard let url = response.url?.absoluteString, 200 ..< 300 ~= response.statusCode else { return }
            internalCache[url] = data
        })
    }
}

func data(request: URLRequest) -> Observable<Data> {
    // 데이터가 이미 사용 가능한지 확인하기 위한 딕셔너리 확인
    if let url = request.url?.absoluteString, let data = internalCache[url] {
        return Observable.just(data)
    }
    
    // cache() 메서드를 통한 데이터 딕셔너리 등록
    return response(request: request).cache().map { response, data -> Data in
        guard 200 ..< 300 ~= response.statusCode else {
            throw RxURLSessionError.requestFailed(response: response, data: data)
        }
        return data
    }
}

class ApiController {
    static let shared = ApiController()
    
    private let apiKey = "Vjzf6NJ7eP6pdzYM4JDLsmDv5k9gDCFx"
    
    func search(text: String) -> Observable<[GiphyGif]> {
        let url = URL(string: "http://api.giphy.com/v1/gifs/search")!
        var request = URLRequest(url: url)
        let keyQueryItem = URLQueryItem(name: "api_key", value: apiKey)
        let searchQueryItem = URLQueryItem(name: "q", value: text)
        let urlComponents = NSURLComponents(url: url, resolvingAgainstBaseURL: true)!
        
        urlComponents.queryItems = [searchQueryItem, keyQueryItem]
        
        request.url = urlComponents.url!
        request.httpMethod = "GET"
        
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        return URLSession.shared.rx
            .decodable(request: request, type: GiphySearchResponse.self)
            .map(\.data)
    }
}

class GifTableViewCell: UITableViewCell {
    @IBOutlet private var gifImageView: UIImageView!
    @IBOutlet private var activityIndicator: UIActivityIndicatorView!
    
    var disposable = SingleAssignmentDisposable()
    
    override func prepareForReuse() {
        super.prepareForReuse()
        gifImageView.prepareForReuse()
        gifImageView.image = nil
        disposable.dispose()
        disposable = SingleAssignmentDisposable()
    }
    
    func downloadAndDisplay(gif url: URL) {
        let request = URLRequest(url: url)
        activityIndicator.startAnimating()
        let image = URLSession.shared.rx.data(request: request)
            .observeOn(MainScheduler.instance)
            .subscribe(onNext: { [weak self] imageData in
                guard let self = self else { return }
                self.gifImageView.animate(withGIFData: imageData)
                self.activityIndicator.stopAnimating()
            })
        disposable.setDisposable(image)
    }
}

import RxNimble

// 기존 test 코드 작성
let result = try! observabe.toBlocking().first()
expect(result).first != 0

// RxNimble을 활용한 코드
expect(observable) != 0

import XCTest
import RxSwift
import RxBlocking
import Nimble
import RxNimble
import OHHTTPStubs

@testable import iGif

class iGifTests: XCTestCase {
  // 테스트할 더미 JSON 객체
  // 미리 정의된 데이터를 사용하면 데이터, 문자열 및 JSON 요청에 대한 테스트를 더 쉽게 작성 가능
  let obj = ["array": ["foo", "bar"], "foo": "bar"] as [String: AnyHashable]
  let request = URLRequest(url: URL(string: "http://raywenderlich.com")!)
  let errorRequest = URLRequest(url: URL(string: "http://rw.com")!)
  
  override func setUp() {
    super.setUp()
    // Put setup code here. This method is called before the invocation of each test method in the class.
    stub(condition: isHost("raywenderlich.com")) { _ in
      return HTTPStubsResponse(jsonObject: self.obj, statusCode: 200, headers: nil)
    }
    stub(condition: isHost("rw.com")) { _ in
      return HTTPStubsResponse(error: RxURLSessionError.unknown)
    }
  }
  
  override func tearDown() {
    // Put teardown code here. This method is called after the invocation of each test method in the class.
    super.tearDown()
    HTTPStubs.removeAllStubs()
  }

  // 첫 번째 쓰기 테스트는 데이터 요청에 대한 테스트
  // 다음 테스트를 테스트 사례 클래스에 추가하여 요청이 nil으로 반환되지 않는지 확인
  func testData() {
    let observable = URLSession.shared.rx.data(request: self.request)
    expect(observable.toBlocking().firstOrNil()).toNot(beNil())
  }

  // {"array":["foo","bar"],"foo":"bar"} 또는, {"foo":"bar","array":["foo","bar"]}로 반환되는 지 확인
  func testString() {
    let observable = URLSession.shared.rx.string(request: self.request)
    let result = observable.toBlocking().firstOrNil() ?? ""

    let option1 = "{\"array\":[\"foo\",\"bar\"],\"foo\":\"bar\"}"
    let option2 = "{\"foo\":\"bar\",\"array\":[\"foo\",\"bar\"]}"

    expect(result == option1 || result == option2).to(beTrue())
  }

  // 해당 JSON Dict로 반환 되는지 확인
  func testJSON() {
    let observable = URLSession.shared.rx.json(request: self.request)
    let obj = self.obj
    let result = observable.toBlocking().firstOrNil()
    expect(result as? [String: AnyHashable]) == obj
  }

  // 오류가 제대로 반환되는지 확인
  // 실제 테스트 시 stub 관련 반환이 NSURLError로 반환
  // RxURLSessionError.unknown 타입으로 반환되도록 확인 필요
  func testError() {
    var erroredCorrectly = false
    let observable = URLSession.shared.rx.json(request: self.errorRequest)
    do {
      _ = try observable.toBlocking().first()
      assertionFailure()
    } catch let error {
      erroredCorrectly = true
      print(type(of: error))
      print(error.localizedDescription)
    }
    expect(erroredCorrectly) == true
  }
}

extension BlockingObservable {
  func firstOrNil() -> Element? {
    do {
      return try first()
    } catch {
      return nil
    }
  }
}

// RxCocoa 기반의 tableView 바인딩
// 단순한 데이터 세트에서는 완벽하게 작동하지만 애니메이션이 부족하고 
// 여러 섹션에 대한 지원이 부족하며 확장성이 좋지 않음
let data = Observable<[String]>.just(
  ["1st place", "2nd place", "3rd place"]
)

data.bind(to: tableView.rx.items(cellIdentifier: "Cell"))
{ index, model, cell in
  cell.placeLabel.text = model
}
.disposed(by: bag)

// RxDataSources 기반의 datasource 바인딩
let dataSource = RxTableViewSectionedReloadDataSource<SectionModel<String, String>>()
Observable.just([SectionModel(model: "Position", items: ["1st", "2nd", "3rd"])])
  .bind(to: tableView.rx.items(dataSource: dataSource))
  .disposed(by: bag)

// 재사용 가능한 뷰를 기반으로 한 셀 구성
dataSource.configureCell = { dataSource, tableView, indexPath, item in
  let cell = tableView.dequeueReusableCell(
    withIdentifier: "Cell", for: indexPath
  )
  cell.placeLabel.text = item
  return cell 
}

// 타이틀 헤더 구성 
dataSource.titleForHeaderInSection = { dataSource, index in
  return dataSource.sectionModels[index].header
}

// 모든 요청 세부 정보를 하나의 호출로 결합하고 서버 응답을 Observable<Data>로 반환
func data(_ method:_ url:parameters:encoding:headers:) -> Observable<Data>
// 서버 응답을 Observable<String>로 반환
func string(_ method:_ url:parameters:encoding:headers:) -> Observable<String>
// 서버 응답을 JSONSerialization을 사용하여 Observable<Any>로 반환
func json(_ method:_ url:parameters:encoding:headers:) -> Observable<Any>

let manager = CentralManager(queue: .main)

// 주변 장치를 검색하는 코드
manager
  .scanForPeripherals(withServices: [serviceIds])
  .flatMap { scannedPeripheral in
    let advertisement = scannedPeripheral.advertisementData
    // Do whatever we want with the advertisement.
  }

// 하나의 기기에 연결
manager.scanForPeripherals(withServices: [serviceId])
  .take(1)
  .flatMap { $0.peripheral.establishConnection() }
  .subscribe(onNext: { peripheral in
      print("Connected to: \(peripheral)")
  })

// 매니저 외에도 특성과 주변기기에 대한 편리한 추상화
// 연결 가능한 주변 장치에 연결하려면 다음을 수행 가능
peripheral.establishConnection()
  .flatMap { $0.discoverServices([serviceId]) }
  .subscribe(onNext: { service in
      print("Service discovered: \(service)")
  })

// 그리고 만약 장비 특성을 찾길 원한다면
peripheral.establishConnection()
  .flatMap { $0.discoverServices([serviceId]) }
  .flatMap { Observable.from($0) }
  .flatMap { $0.discoverCharacteristics([characteristicId])}
  .subscribe(onNext: { characteristic in 
     print("Characteristic discovered: \(characteristic)")
  })