final class SearchBox: UIView {
    lazy var textField: UITextField = {
        let textField = UITextField()
        let imageView = UIImageView(image: R.image.search()!)
        imageView.frame.size = CGSize(width: 20 + 8, height: 20)
        imageView.contentMode = .scaleAspectFit
        textField.leftView = imageView
        textField.leftViewMode = .always

        return textField
    }()

    lazy var filterButton: UIButton = {
        let button = UIButton(type: .custom)
        button.setImage(R.image.filter()!, for: .normal)
        button.imageEdgeInsets = UIEdgeInsets(top: 10, left: 10, bottom: 10, right: 10)

        return button
    }()

    lazy var backView: UIView = {
        let view = UIView()
        view.backgroundColor = .white
        view.layer.cornerRadius = 10
        view.layer.borderColor = R.color.lightGray.cgColor
        view.layer.borderWidth = 0.5
        view.layer.shadowOffset = CGSize(width: 1, height: 1)
        view.layer.shadowOpacity = 0.8
        view.layer.shadowColor = R.color.lightGray.cgColor

        return view
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)

        setup()
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError()
    }

    private func setup() {
        addSubviews([backView, textField, filterButton])

        NSLayoutConstraint.on([
            filterButton.rightAnchor.constraint(equalTo: rightAnchor, constant: -8),
            filterButton.centerYAnchor.constraint(equalTo: centerYAnchor),
            filterButton.heightAnchor.constraint(equalToConstant: 44),
            filterButton.widthAnchor.constraint(equalToConstant: 44),

            textField.centerYAnchor.constraint(equalTo: centerYAnchor),
            textField.leftAnchor.constraint(equalTo: leftAnchor, constant: 16),
            textField.rightAnchor.constraint(equalTo: filterButton.leftAnchor, constant: -8)
        ])

        NSLayoutConstraint.on([
            backView.pinEdges(view: self, inset: UIEdgeInsets(top: 4, left: 4, bottom: -4, right: -4))
        ])
    }
}

imageView.frame.size = CGSize(width: 20 + 8, height: 20)
imageView.contentMode = .scaleAspectFit

for family in UIFont.familyNames.sorted() {
    let names = UIFont.fontNames(forFamilyName: family)
    print("Family: \(family) Font names: \(names)")
}

let tabBarController = UITabBarController()

let navigationController1 = UINavigationController(rootViewController: viewController1)
let navigationController2 = UINavigationController(rootViewController: viewController2)
let navigationController3 = UINavigationController(rootViewController: viewController3)

navigationController2.isNavigationBarHidden = true

navigationController1.tabBarItem.image = R.image.profile()
navigationController2.tabBarItem.image = R.image.books()
navigationController3.tabBarItem.image = R.image.settings()

tabBarController.tabBar.tintColor = .yellow
tabBarController.viewControllers = [navigationController1, navigationController2, navigationController3]

final class NetworkClient {
    let session: URLSession
    let baseUrl: URL

    init(session: URLSession = .shared, baseUrl: URL) {
        self.session = session
        self.baseUrl = baseUrl
    }

    func make(options: Options, completion: @escaping (Result<Data, Error>) -> Void) {
        guard let request = options.toRequest(baseUrl: baseUrl) else {
            completion(.failure(AppError.request))
            return
        }

        let task = session.dataTask(with: request, completionHandler: { data, _, error in
            if let data = data {
                completion(.success(data))
            } else if let error = error {
                completion(.failure(error))
            } else {
                completion(.failure(AppError.unknown))
            }
        })

        task.resume()
    }

    func makeJson(options: Options, completion: @escaping (Result<[String: Any], Error>) -> Void) {
        make(options: options, completion: { result in
            let mapped = result.flatMap({ data -> Result<[String: Any], Error> in
                do {
                    let json = try JSONSerialization.jsonObject(with: data, options: [])
                    if let json = json as? [String: Any] {
                        return Result<[String: Any], Error>.success(json)
                    } else {
                        return Result<[String: Any], Error>.failure(AppError.parse)
                    }
                } catch {
                    return Result<[String: Any], Error>.failure(error)
                }
            })

            completion(mapped)
        })
    }
}

struct Options {
    var path: String = ""
    var httpMethod: HttpMethod = .get
    var parameters: [String: Any] = [:]

    func toRequest(baseUrl: URL) -> URLRequest? {
        let url = baseUrl.appendingPathComponent(path)
        let items: [URLQueryItem] = parameters.map({ tuple -> URLQueryItem in
            return URLQueryItem(name: tuple.key, value: "\(tuple.value)")
        })

        var components = URLComponents(url: url, resolvingAgainstBaseURL: false)

        if httpMethod == .get {
            components?.queryItems = items
        }

        guard let finalUrl = components?.url else {
            return nil
        }

        var request = URLRequest(url: finalUrl)

        if httpMethod == .post {
            let data = try? JSONSerialization.data(withJSONObject: parameters, options: [])
            request.httpBody = data
        }

        request.httpMethod = httpMethod.rawValue
        return request
    }
}

enum AppError: Error {
    case request
    case unknown
    case parse
}

enum HttpMethod: String {
    case get = "GET"
    case put = "PUT"
    case post = "POST"
    case patch = "PATCH"
}

import UIKit
import Stripe

final class MainController: UIViewController {

    func showPayment() {
        let addCardViewController = STPAddCardViewController()
        addCardViewController.delegate = self
        let navigationController = UINavigationController(rootViewController: addCardViewController)

        present(navigationController, animated: true, completion: nil)
    }
}

extension MainController: STPAddCardViewControllerDelegate {
    func addCardViewControllerDidCancel(_ addCardViewController: STPAddCardViewController) {
        dismiss(animated: true, completion: nil)
    }

    func addCardViewController(_ addCardViewController: STPAddCardViewController, didCreateToken token: STPToken, completion: @escaping STPErrorBlock) {
        _ = token.tokenId
        completion(nil)
        dismiss(animated: true, completion: nil)
    }
}

final class EphemeralKeyClient: NSObject, STPCustomerEphemeralKeyProvider {
    let client = NetworkClient(baseUrl: URL(string: "http://localhost:8080")!)

    func createCustomerKey(withAPIVersion apiVersion: String, completion: @escaping STPJSONResponseCompletionBlock) {
        var options = Options()
        options.httpMethod = .post
        options.path = "ephemeral_keys"
        options.parameters = [
            "api_version": apiVersion
        ]

        client.makeJson(options: options, completion: { result in
            switch result {
            case .success(let json):
                completion(json, nil)
            case .failure(let error):
                completion(nil, error)
            }
        })
    }
}

final class MainController: UIViewController {
    let client = EphemeralKeyClient()
    let customerContext: STPCustomerContext
    let paymentContext: STPPaymentContext

    init() {
        self.customerContext = STPCustomerContext(keyProvider: client)
        self.paymentContext = STPPaymentContext(customerContext: customerContext)
        super.init(nibName: nil, bundle: nil)
        paymentContext.delegate = self
        paymentContext.hostViewController = self
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func start() {
        paymentContext.presentShippingViewController()
    }
}

final class PaymentClient {
    let client = NetworkClient(baseUrl: URL(string: "http://192.168.210.219:8080")!)

    func requestCharge(source: STPSourceProtocol, completion: @escaping (Result<(), Error>) -> Void) {
        var options = Options()
        options.httpMethod = .post
        options.path = "request_charge"
        options.parameters = [
            "stripe_id": source.stripeID
        ]

        client.makeJson(options: options, completion: { result in
            completion(result.map({ _ in () }))
        })
    }
}

paymentContext.requestPayment()

extension MainController: STPPaymentContextDelegate {
    func paymentContext(_ paymentContext: STPPaymentContext, didCreatePaymentResult paymentResult: STPPaymentResult, completion: @escaping STPErrorBlock) {
        client.requestCharge(source: paymentResult.source, completion: { result in
            switch result {
            case .success:
                completion(nil)
            case .failure(let error):
                completion(error)
            }
        })
    }
}

let cardParams = STPCardParams()
cardParams.number = "4242424242424242"
cardParams.expMonth = 10
cardParams.expYear = 2021
cardParams.cvc = "123"

STPAPIClient.shared().createToken(withCard: cardParams) { (token: STPToken?, error: Error?) in
    guard let token = token, error == nil else {
        // Present error to user...
        return
    }

    submitTokenToBackend(token, completion: { (error: Error?) in
        if let error = error {
            // Present error to user...
        }
        else {
            // Continue with payment...
        }
    })
}

paymentContext.pushShippingViewController()
paymentContext.pushPaymentOptionsViewController()

final class PaymentClient: NSObject {
    let client = NetworkClient(baseUrl: URL(string: "localhost:8080")!)

    func requestCharge(token: STPToken, completion: @escaping (Result<(), Error>) -> Void) {
        var options = Options()
        options.httpMethod = .post
        options.path = "request_charge_apple_pay"
        options.parameters = [
            "token": token.tokenId
        ]

        client.make(options: options, completion: { result in
            completion(result.map({ _ in () }))
        })
    }

    func useApplePay(payment: PKPayment, completion: @escaping (Result<(), Error>) -> Void) {
        STPAPIClient.shared().createToken(with: payment, completion: { (token: STPToken?, error: Error?) in
            guard let token = token, error == nil else {
                return
            }

            self.requestCharge(token: token, completion: completion)
        })
    }
}

extension MainController {
    func showApplePay() {
        let merchantId = "merchant.com.onmyway133.MyApp"
        let paymentRequest = Stripe.paymentRequest(withMerchantIdentifier: merchantId, country: "US", currency: "USD")
        paymentRequest.paymentSummaryItems = [
            PKPaymentSummaryItem(label: "Rubber duck", amount: 1.5)
        ]

        guard Stripe.canSubmitPaymentRequest(paymentRequest) else {
            assertionFailure()
            return
        }

        guard let authorizationViewController = PKPaymentAuthorizationViewController(paymentRequest: paymentRequest) else {
            assertionFailure()
            return
        }

        authorizationViewController.delegate = self
        innerNavigationController.present(authorizationViewController, animated: true, completion: nil)
    }
}

extension MainController: PKPaymentAuthorizationViewControllerDelegate {
    func paymentAuthorizationViewControllerDidFinish(_ controller: PKPaymentAuthorizationViewController) {
        controller.dismiss(animated: true, completion: nil)
    }

    func paymentAuthorizationViewController(
        _ controller: PKPaymentAuthorizationViewController,
        didAuthorizePayment payment: PKPayment,
        handler completion: @escaping (PKPaymentAuthorizationResult) -> Void) {

        client.useApplePay(payment: payment, completion: { result in
            switch result {
            case .success:
                completion(.init(status: .success, errors: nil))
            case .failure(let error):
                completion(.init(status: .failure, errors: [error]))
            }
        })
    }
}

if Stripe.deviceSupportsApplePay() {
    STPPaymentConfiguration.shared().appleMerchantIdentifier = "merchant.com.onmyway133.MyApp"
}

paymentContext.pushPaymentOptionsViewController()

func paymentOptionsViewController(_ paymentOptionsViewController: STPPaymentOptionsViewController, didSelect paymentOption: STPPaymentOption) {
	// No op
}

class Recorder<T> {
    var items = [T]()
    let bag = DisposeBag()

    func on(arraySubject: PublishSubject<[T]>) {
        arraySubject.subscribe(onNext: { value in
            self.items = value
        }).disposed(by: bag)
    }

    func on(valueSubject: PublishSubject<T>) {
        valueSubject.subscribe(onNext: { value in
            self.items.append(value)
        }).disposed(by: bag)
    }
}

final class BookViewModelTests: XCTestCase {
    func testBooks() throws {
        let expectation = self.expectation(description: #function)
        let recorder = Recorder<Book>()
        let viewModel = BookViewModel(bookClient: MockBookClient())
        recorder.on(arraySubject: viewModel.books)
        viewModel.load()

        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.5, execute: {
            expectation.fulfill()
        })

        wait(for: [expectation], timeout: 2)
        XCTAssertEqual(recorder.items.count, 3)
    }
}

extension XCTestCase {
    func waitOrFail(timeout: TimeInterval) {
        let expectation = self.expectation(description: #function)

        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + timeout, execute: {
            expectation.fulfill()
        })

        wait(for: [expectation], timeout: timeout + 2)
    }
}

extension Result {
    func to(subject: PublishSubject<Success>) {
        switch self {
        case .success(let value):
            subject.onNext(value)
        case .failure(let error):
            subject.onError(error)
        }
    }
}

func schedule() {
    DispatchQueue.main.async {
      self.timer = Timer.scheduledTimer(timeInterval: 20, target: self,
                                   selector: #selector(self.timerDidFire(timer:)), userInfo: nil, repeats: false)
    }
}

@objc private func timerDidFire(timer: Timer) {
    print(timer)
}

DispatchQueue.main.async {
      self.timer = Timer.scheduledTimer(withTimeInterval: 20, repeats: false) { timer in
        print(timer)
      }
}

struct A {

  // return type
  func get() -> String { return "" }
  func get() -> Int { return 1 }

  // mix of parameter type and return type
  func get(param: String) -> String { return "" }
  func get(param: String) -> Int { return 1 }
  func get(param: Int) -> Int { return 1 }
  func get(param: Int) -> String { return "" }

  subscript(param: String) -> String { return "" }
  subscript(param: String) -> Int { return 1 }
  subscript(param: Int) -> Int { return 1 }
  subscript(param: Int) -> String { return "" }

  // parameter label
  func set(int: Int) {}
  func set(string: String) {}

  // concrete type from generic
  func get(param: Array<String>) -> String { return "" }
  func get(param: Array<Int>) -> Int { return 1 }

  subscript(param: Array<String>) -> String { return "" }
  subscript(param: Array<Int>) -> Int { return 1 }
}

class B: NSObject {

  func get() -> String { return "" }
  func get() -> Int { return 1 }
}

func f<T>(t: T) {
  print("T")
}

func f(string: String) {
  print("String")
}

func f(int: Int) {
  print("Int")
}

let home = NSSearchPathForDirectoriesInDomains(.applicationScriptsDirectory, .userDomainMask, true).first!
let path = home.appending(".XcodeWayExtensions/XcodeWayScript.scpt")
let exists = FileManager.default.fileExists(atPath: path)

public struct Google_Protobuf_Empty {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

import SwiftProtobuf

let empty = Google_Protobuf_Empty()

var person = Person()
person.mode = Person.OneOf_Mode.Human()

import Foundation

public class Token {
    private let lock = NSRecursiveLock()
    private var _isCancelled = false
    private var callbacks: [() -> Void] = []
    
    public init() {}

    public func isCancelled() -> Bool {
        return lock.whenLock {
            return _isCancelled
        }
    }
    
    public func cancel() {
        lock.whenLock {
            guard self._isCancelled == false else {
                return
            }

            self._isCancelled = true
            self.callbacks.forEach { $0() }
            self.callbacks.removeAll()
        }
    }
    
    public func onCancel(_ callback: @escaping () -> Void) {
        lock.whenLock {
            self.callbacks.append(callback)
        }
    }
}

public class Resolver<T> {
    public let queue: DispatchQueue
    public let token: Token
    private var callback: (Result<T, Error>) -> Void
    
    public init(queue: DispatchQueue, token: Token, callback: @escaping (Result<T, Error>) -> Void) {
        self.queue = queue
        self.token = token
        self.callback = callback
    }
    
    public func complete(value: T) {
        self.handle(result: .success(value))
    }
    
    public func fail(error: Error) {
        self.handle(result: .failure(error))
    }
    
    public func handle(result: Result<T, Error>) {
        queue.async {
            self.callback(result)
            self.callback = { _ in }
        }
    }
}

public class Future<T> {
    public let work: (Resolver<T>) -> Void
    
    public init(work: @escaping (Resolver<T>) -> Void) {
        self.work = work
    }
    
    public static func fail(error: Error) -> Future<T> {
        return Future<T>.result(.failure(error))
    }
    
    public static func complete(value: T) -> Future<T> {
        return .result(.success(value))
    }
    
    public static func result(_ result: Result<T, Error>) -> Future<T> {
        return Future<T>(work: { resolver in
            switch result {
            case .success(let value):
                resolver.complete(value: value)
            case .failure(let error):
                resolver.fail(error: error)
            }
        })
    }
    
    public func run(queue: DispatchQueue = .serial(), token: Token = Token(), completion: @escaping (Result<T, Error>) -> Void) {
        queue.async {
            if (token.isCancelled()) {
                completion(.failure(NetworkError.cancelled))
                return
            }
            
            let resolver = Resolver<T>(queue: queue, token: token, callback: completion)
            self.work(resolver)
        }
    }
    
    public func map<U>(transform: @escaping (T) -> U) -> Future<U> {
        return Future<U>(work: { resolver in
            self.run(queue: resolver.queue, token: resolver.token, completion: { result in
                resolver.handle(result: result.map(transform))
            })
        })
    }
    
    public func flatMap<U>(transform: @escaping (T) -> Future<U>) -> Future<U> {
        return Future<U>(work: { resolver in
            self.run(queue: resolver.queue, token: resolver.token, completion: { result in
                switch result {
                case .success(let value):
                    let future = transform(value)
                    future.run(queue: resolver.queue, token: resolver.token, completion: { newResult in
                        resolver.handle(result: newResult)
                    })
                case .failure(let error):
                    resolver.fail(error: error)
                }
            })
        })
    }
    
    public func catchError(transform: @escaping (Error) -> Future<T>) -> Future<T> {
        return Future<T>(work: { resolver in
            self.run(queue: resolver.queue, token: resolver.token, completion: { result in
                switch result {
                case .success(let value):
                    resolver.complete(value: value)
                case .failure(let error):
                    let future = transform(error)
                    future.run(queue: resolver.queue, token: resolver.token, completion: { newResult in
                        resolver.handle(result: newResult)
                    })
                }
            })
        })
    }
    
    public func delay(seconds: TimeInterval) -> Future<T> {
        return Future<T>(work: { resolver in
            resolver.queue.asyncAfter(deadline: DispatchTime.now() + seconds, execute: {
                self.run(queue: resolver.queue, token: resolver.token, completion: { result in
                    resolver.handle(result: result)
                })
            })
        })
    }
    
    public func log(closure: @escaping (Result<T, Error>) -> Void) -> Future<T> {
        return Future<T>(work: { resolver in
            self.run(queue: resolver.queue, token: resolver.token, completion: { result in
                closure(result)
                resolver.handle(result: result)
            })
        })
    }
    
    public static func sequence(futures: [Future<T>]) -> Future<Sequence<T>> {
        var index = 0
        var values = [T]()
        
        func runNext(resolver: Resolver<Sequence<T>>) {
            guard index < futures.count else {
                let sequence = Sequence(values: values)
                resolver.complete(value: sequence)
                return
            }
            
            let future = futures[index]
            index += 1
            
            future.run(queue: resolver.queue, token: resolver.token, completion: { result in
                switch result {
                case .success(let value):
                    values.append(value)
                    runNext(resolver: resolver)
                case .failure(let error):
                    resolver.fail(error: error)
                }
            })
        }
        
        return Future<Sequence<T>>(work: runNext)
    }
}

extension NSLocking {
    @inline(__always)
    func whenLock<T>(_ closure: () throws -> T) rethrows -> T {
        lock()
        defer { unlock() }
        return try closure()
    }

    @inline(__always)
    func whenLock(_ closure: () throws -> Void) rethrows {
        lock()
        defer { unlock() }
        try closure()
    }
}

import Foundation

public protocol QueryBuilder {
    func build() -> [URLQueryItem]
}

public class DefaultQueryBuilder: QueryBuilder {
    public let parameters: JSONDictionary

    public init(parameters: JSONDictionary = [:]) {
        self.parameters = parameters
    }

    public func build() -> [URLQueryItem] {
        var components = URLComponents()
        
        let parser = ParameterParser()
        let pairs = parser
            .parse(parameters: parameters)
            .map({ $0 })
            .sorted(by: <)
        
        components.queryItems = pairs.map({ key, value in
            URLQueryItem(name: key, value: value)
        })
        
        return components.queryItems ?? []
    }
    
    public func build(queryItems: [URLQueryItem]) -> String {
        var components = URLComponents()
        components.queryItems = queryItems.map({
            return URLQueryItem(name: escape($0.name), value: escape($0.value ?? ""))
        })
        
        return components.query ?? ""
    }
    
    public func escape(_ string: String) -> String {
        return string.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? ""
    }
}

import Foundation

public class JsonBodyBuilder: BodyBuilder {
    public let parameters: JSONDictionary
    
    public init(parameters: JSONDictionary) {
        self.parameters = parameters
    }
    
    public func build() -> ForBody? {
        guard let data = try? JSONSerialization.data(
            withJSONObject: parameters,
            options: JSONSerialization.WritingOptions()
        ) else {
            return nil
        }
        
        return ForBody(body: data, headers: [
            Header.contentType.rawValue: "application/json"
        ])
    }
}

import Foundation

public class Networking {
    public let session: URLSession
    public let mockManager = MockManager()
    
    public var before: (URLRequest) -> URLRequest = { $0 }
    public var catchError: (Error) -> Future<Response> = { error in Future.fail(error: error) }
    public var validate: (Response) -> Future<Response> = { Future.complete(value: $0) }
    public var logResponse: (Result<Response, Error>) -> Void = { _ in }
    
    public init(session: URLSession = .shared) {
        self.session = session
    }
    
    public func make(options: Options, baseUrl: URL) -> Future<Response> {
        let builder = UrlRequestBuilder()
        do {
            let request = try builder.build(options: options, baseUrl: baseUrl)
            return make(request: request)
        } catch {
            return Future<Response>.fail(error: error)
        }
    }
    
    public func make(request: URLRequest) -> Future<Response> {
        if let mock = mockManager.findMock(request: request) {
            return mock.future.map(transform: { Response(data: $0, urlResponse: URLResponse()) })
        }
        
        let future = Future<Response>(work: { resolver in
            let task = self.session.dataTask(with: request, completionHandler: { data, response, error in
                if let data = data, let urlResponse = response {
                    resolver.complete(value: Response(data: data, urlResponse: urlResponse))
                } else if let error = error {
                    resolver.fail(error: NetworkError.urlSession(error, response))
                } else {
                    resolver.fail(error: NetworkError.unknownError)
                }
            })
            
            resolver.token.onCancel {
                task.cancel()
            }
            
            task.resume()
        })
        
        return future
            .catchError(transform: self.catchError)
            .flatMap(transform: self.validate)
            .log(closure: self.logResponse)
    }
}

import Foundation

public class Mock {
    public let options: Options
    public let future: Future<Data>
    
    public init(options: Options, future: Future<Data>) {
        self.options = options
        self.future = future
    }
    
    public static func on(options: Options, data: Data) -> Mock {
        return Mock(options: options, future: Future.complete(value: data))
    }
    
    public static func on(options: Options, error: Error) -> Mock {
        return Mock(options: options, future: Future.fail(error: error))
    }
    
    public static func on(options: Options, file: String, fileExtension: String, bundle: Bundle = Bundle.main) -> Mock {
        guard
            let url = bundle.url(forResource: file, withExtension: fileExtension),
            let data = try? Data(contentsOf: url)
        else {
            return .on(options: options, error: NetworkError.invalidMock)
        }
        
        return .on(options: options, data: data)
    }
}

var components = URLComponents(string: "https://google.com/")
components?.path = "abc/"
components?.url

var components = URLComponents(string: "https://google.com/")
components?.path = "/abc/"
components?.url
components?.queryItems = [URLQueryItem(name: "q", value: "pokemon")]

var url = URL(string: "https://google.com/")
url?.appendPathComponent("/abc?q=pokemon")
url