func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
  OneSignal.appID = ""
}

func application(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
  OneSignal.handleDeviceToken(deviceToken)
}

import UIKit

struct Utils {

  static func parse(deviceToken data: NSData) -> String {
    let buffer = UnsafePointer<CChar>(data.bytes)
    var string = ""

    for i in 0..<data.length {
      string += String(format: "%02.2hhx", arguments: [buffer[i]])
    }

    return string
  }

  static func deviceModel() -> String {
    var systemInfo = utsname()
    uname(&systemInfo)
    var v = systemInfo.machine

    var deviceModel = ""
    let _ = withUnsafePointer(&v) {
      deviceModel = String(UTF8String: UnsafePointer($0)) ?? ""
    }

    return deviceModel
  }

  static func systemVersion() -> String {
    let version = NSProcessInfo.processInfo().operatingSystemVersion

    return "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"
  }

  static func language() -> String {
    return NSLocale.preferredLanguages().first!
  }

  static func timezone() -> Int {
    return NSTimeZone.localTimeZone().secondsFromGMT
  }

  static func soundFiles() -> [String] {
    guard let resourcePath = NSBundle.mainBundle().resourcePath
      else { return [] }

    let files = try? NSFileManager.defaultManager()
      .contentsOfDirectoryAtPath(resourcePath)
      .filter {
        return $0.hasSuffix(".wav") || $0.hasSuffix(".mp3")
      }

    return files ?? []
  }

  static func versionNumber() -> String? {
    return NSBundle.mainBundle().infoDictionary?["CFBundleShortVersionString"] as? String
  }

  static func buildNumber() -> String? {
    return NSBundle.mainBundle().infoDictionary?["CFBundleVersionString"] as? String
  }

  static func netType() -> Int {
    // Reachability
    return 0
  }
}

import Foundation

public struct UserDefaults {

  struct Key {
    static let playerID: String = "Dust-OneSignal-Player-ID-Key"
    static let deviceToken: String = "Dust-OneSignal-Device-Token-Key"
    static let subscribed: String = "Dust-OneSignal-Disable-Subscribed-Key"
  }

  public static var playerID: String? {
    get {
      return NSUserDefaults.standardUserDefaults().stringForKey(Key.playerID)
    }

    set {
      NSUserDefaults.standardUserDefaults().setObject(newValue, forKey: Key.playerID)
      NSUserDefaults.standardUserDefaults().synchronize()
    }
  }

  public static var deviceToken: String? {
    get {
      return NSUserDefaults.standardUserDefaults().stringForKey(Key.deviceToken)
    }

    set {
      NSUserDefaults.standardUserDefaults().setObject(newValue, forKey: Key.deviceToken)
      NSUserDefaults.standardUserDefaults().synchronize()
    }
  }

  public static var subscribed: Bool {
    get {
      return NSUserDefaults.standardUserDefaults().boolForKey(Key.subscribed)
    }

    set {
      NSUserDefaults.standardUserDefaults().setBool(newValue, forKey: Key.subscribed)
      NSUserDefaults.standardUserDefaults().synchronize()
    }
  }
}

import Foundation
import Alamofire

public struct OneSignal {

  static var appID: String = ""
  static let version = "020115"
  static let baseURL = NSURL(string: "https://onesignal.com/api/v1")!

  enum NotificationType: Int {
    case subscribed = 7
    case unsubscribed = -2

    static func value() -> Int {
      return UserDefaults.subscribed
        ? NotificationType.subscribed.rawValue : NotificationType.unsubscribed.rawValue
    }
  }

  enum Provisioning: Int {
    case development = 1
  }

  public static func setup(appID appID: String) {
    NSUserDefaults.standardUserDefaults().registerDefaults([
      UserDefaults.Key.subscribed: true
    ])

    OneSignal.appID = appID
  }

  public static func registerOrUpdateSession(completion: ((String?) -> Void)? = nil) {
    guard let bundleID = NSBundle.mainBundle().bundleIdentifier,
      let deviceToken = UserDefaults.deviceToken
    else {
      return
    }

    var params: [String: AnyObject] = [
      "app_id" : appID,
      "device_model" : Utils.deviceModel(),
      "device_os" : Utils.systemVersion(),
      "language" : Utils.language(),
      "timezone" : NSNumber(integer: Utils.timezone()),
      "device_type" : NSNumber(integer : 0),
      "sounds" : Utils.soundFiles(),
      "sdk" : version,
      "identifier" : deviceToken,
      "net_type" : NSNumber(integer: Utils.netType()),
      "rooted": NSNumber(bool: false),
      "as_id": "OptedOut",
      "sdk_type": "native",
      "ios_bundle": bundleID,
      "game_version": Utils.versionNumber() ?? "",
      "notification_types": NotificationType.value(),
    ]

    #if DEBUG
      params["test_type"] = Provisioning.development.rawValue
    #endif

    let url: NSURL

    if let playerID = UserDefaults.playerID {
      url = baseURL.URLByAppendingPathComponent("players/\(playerID)/on_session")
    } else {
      url = baseURL.URLByAppendingPathComponent("players")
    }

    Alamofire
    .request(.POST, url, parameters: params)
    .responseJSON { response in
      guard let json = response.result.value as? [String: AnyObject]
      else {
        completion?(nil)
        return
      }

      if let id = json["id"] as? String {
        UserDefaults.playerID = id
        completion?(id)
      } else if let value = json["success"] as? Int,
        playerID = UserDefaults.playerID where value == 1 {
        completion?(playerID)
      } else {
        completion?(nil)
      }
    }
  }

  public static func handle(deviceToken data: NSData) {
    UserDefaults.deviceToken = Utils.parse(deviceToken: data)
    registerOrUpdateSession()
  }

  public static func update(subscription subscribed: Bool) {
    guard let playerID = UserDefaults.playerID else { return }
    UserDefaults.subscribed = subscribed

    let url = baseURL.URLByAppendingPathComponent("players/\(playerID)")
    let params: [String: AnyObject] = [
      "app_id": appID,
      "notification_types": NotificationType.value()
    ]

    Alamofire
    .request(.PUT, url, parameters: params)
    .responseJSON { response in
      print(response)
    }
  }

  public static func update(badge count: Int) {
    guard let playerID = UserDefaults.playerID else { return }

    let url = baseURL.URLByAppendingPathComponent("players/\(playerID)")
    let params: [String: AnyObject] = [
      "app_id": appID,
      "badge_count": count
    ]

    Alamofire
      .request(.PUT, url, parameters: params)
      .responseJSON { response in

    }
  }

  public static func getPlayerID(completion: String -> Void) {
    if let playerID = UserDefaults.playerID {
      completion(playerID)
      return
    }

    registerOrUpdateSession { playerID in
      if let playerID = playerID {
        completion(playerID)
      }
    }
  }
}

import Foundation

public class Debouncer {
    private let delay: TimeInterval
    private var workItem: DispatchWorkItem?

    public init(delay: TimeInterval) {
        self.delay = delay
    }

    /// Trigger the action after some delay
    public func run(action: @escaping () -> Void) {
        workItem?.cancel()
        workItem = DispatchWorkItem(block: action)
        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem!)
    }
}

import XCTest

class DebouncerTests: XCTestCase {

    func testDebounce() {
        let expectation = self.expectation(description: #function)
        let debouncer = Debouncer(delay: 0.5)
        var value = 0

        debouncer.run(action: {
            value = 1
        })

        debouncer.run(action: {
            value = 2
        })

        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.2, execute: {
            debouncer.run(action: {
                value = 3
            })
        })

        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.71, execute: {
            XCTAssertEqual(value, 3)
            expectation.fulfill()
        })

        wait(for: [expectation], timeout: 1.2)
    }
}

final class LifecyclerHandler {
    private var observer: AnyObject!
    var action: (() -> Void)?
    private let debouncer = Debouncer(delay: 1.0)

    func setup() {
        observer = NotificationCenter.default.addObserver(
            forName: UIApplication.didBecomeActiveNotification,
            object: nil,
            queue: .main,
            using: { [weak self] _ in
                self?.debouncer.run {
                    self?.action?()
                }
        })
    }
}

private let lifecycleHandler = LifecyclerHandler()

override func viewDidLoad() {
    super.viewDidLoad()

  
    lifecycleHandler.action = {
        Deps.userHandler.refreshToken()
    }

    lifecycleHandler.setup()
}

accessibilityIdentifier = "MapView"

let map = app.otherElements.matching(identifier: "MapView").element(boundBy: 0)
map.pinch(withScale: 2, velocity: 1)
map.rotate(CGFloat.pi/3, withVelocity: 1.0)
map.swipeLeft()
map.swipeRight()
map.swipeDown()
map.swipeDown()

mapView.accessibilityElementsHidden = false

map().pinch(withScale: 0.05, velocity: -1)

let map = app.otherElements[Constant.AccessibilityId.mapView.rawValue]
let pin = app.otherElements
            .matching(identifier: Constant.AccessibilityId.pin.rawValue)
            .element(boundBy: 0)

let coordinate = pin.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
coordinate.tap()

Array(0..<pins.count).forEach {
    let pin = pins.element(boundBy: $0)
    if pin.isHittable {
        pin.tap()
    }
}

extension NSPredicate {
    static func contains(identifier: String) -> NSPredicate {
        return NSPredicate(format: "identifier CONTAINS[c] '\(text)'")
    }
}

let pin = map()
    .buttons.matching(NSPredicate.contains("MyStopMarker"))
    .element(boundBy: 0)

pin.tap()

final class InsetButton: UIButton {
    required init(text: String) {
        super.init(frame: .zero)

        titleLabel?.textColor = .white
        setTitle(text, for: .normal)

        layer.cornerRadius = 15
        layer.masksToBounds = true
        backgroundColor = .black
        isUserInteractionEnabled = false
    }

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

    override var intrinsicContentSize: CGSize {
        let size = super.intrinsicContentSize
        return CGSize(width: size.width + 24, height: size.height)
    }
}

import UIKit

final class PagerView: UIView {
    let scrollView = UIScrollView()

    private(set) var pages: [UIView] = []
    private let contentView = UIView()

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

        setup()
    }

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

    private func setup() {
        scrollView.isPagingEnabled = true
        scrollView.showsHorizontalScrollIndicator = false

        addSubview(scrollView)
        scrollView.addSubview(contentView)

        if #available(iOS 12.0, *) {
            scrollView.translatesAutoresizingMaskIntoConstraints = false
            contentView.translatesAutoresizingMaskIntoConstraints = false

            NSLayoutConstraint.on([
                scrollView.frameLayoutGuide.pinEdges(view: self)
            ])

            NSLayoutConstraint.on([
                scrollView.contentLayoutGuide.pinEdges(view: contentView),
                [scrollView.contentLayoutGuide.heightAnchor.constraint(
                    equalTo: scrollView.frameLayoutGuide.heightAnchor
                )]
            ])
        } else {
            NSLayoutConstraint.on([
                scrollView.pinEdges(view: self),
                scrollView.pinEdges(view: contentView)
            ])

            NSLayoutConstraint.on([
                contentView.heightAnchor.constraint(equalTo: heightAnchor)
            ])
        }
    }

    func update(pages: [UIView]) {
        clearExistingViews()

        self.pages = pages
        setupConstraints()
    }

    private func setupConstraints() {
        pages.enumerated().forEach { tuple in
            let index = tuple.offset
            let page = tuple.element

            contentView.addSubview(page)

            NSLayoutConstraint.on([
                page.topAnchor.constraint(equalTo: scrollView.topAnchor),
                page.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
                page.widthAnchor.constraint(equalTo: scrollView.widthAnchor)
            ])

            if index == 0 {
                NSLayoutConstraint.on([
                    page.leftAnchor.constraint(equalTo: contentView.leftAnchor)
                ])
            } else {
                NSLayoutConstraint.on([
                    page.leftAnchor.constraint(equalTo: pages[index - 1].rightAnchor)
                ])
            }

            if index == pages.count - 1 {
                NSLayoutConstraint.on([
                    page.rightAnchor.constraint(equalTo: contentView.rightAnchor)
                ])
            }
        }
    }

    private func clearExistingViews() {
        pages.forEach {
            $0.removeFromSuperview()
        }
    }
}

extension UILayoutGuide {
    func pinEdges(view: UIView, inset: UIEdgeInsets = UIEdgeInsets.zero) -> [NSLayoutConstraint] {
        return [
            leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: inset.left),
            trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: inset.right),
            topAnchor.constraint(equalTo: view.topAnchor, constant: inset.top),
            bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: inset.bottom)
        ]
    }
}

imageView.setContentCompressionResistancePriority(UILayoutPriority.defaultLow, for: .vertical)

extension NSLayoutConstraint {

    /// Disable auto resizing mask and activate constraints
    ///
    /// - Parameter constraints: constraints to activate
    static func on(_ constraints: [NSLayoutConstraint]) {
        constraints.forEach {
            ($0.firstItem as? UIView)?.translatesAutoresizingMaskIntoConstraints = false
            $0.isActive = true
        }
    }

    static func on(_ constraintsArray: [[NSLayoutConstraint]]) {
        let constraints = constraintsArray.flatMap({ $0 })
        NSLayoutConstraint.on(constraints)
    }

    func priority(_ value: Float) -> NSLayoutConstraint {
        priority = UILayoutPriority(value)
        return self
    }
}

extension Array where Element == NSLayoutConstraint {
    func priority(_ value: Float) -> [NSLayoutConstraint] {
        forEach {
            $0.priority = UILayoutPriority(value)
        }

        return self
    }
}

extension UILayoutGuide {
    func pinEdges(view: UIView, inset: UIEdgeInsets = UIEdgeInsets.zero) -> [NSLayoutConstraint] {
        return [
            leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: inset.left),
            trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: inset.right),
            topAnchor.constraint(equalTo: view.topAnchor, constant: inset.top),
            bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: inset.bottom)
        ]
    }
}

extension UIView {
    func pinEdges(view: UIView, inset: UIEdgeInsets = UIEdgeInsets.zero) -> [NSLayoutConstraint] {
        return [
            leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: inset.left),
            trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: inset.right),
            topAnchor.constraint(equalTo: view.topAnchor, constant: inset.top),
            bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: inset.bottom)
        ]
    }

    func pinCenter(view: UIView, offset: CGPoint = .zero) -> [NSLayoutConstraint] {
        return [
            centerXAnchor.constraint(equalTo: view.centerXAnchor, constant: offset.x),
            centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: offset.y)
        ]
    }

    func padding(view: UIView, _ constant: CGFloat = 0) -> [NSLayoutConstraint] {
        return [
            leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: constant),
            trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -constant)
        ]
    }

    func size(_ constant: CGFloat) -> [NSLayoutConstraint] {
        return [
            widthAnchor.constraint(equalToConstant: constant),
            heightAnchor.constraint(equalToConstant: constant)
        ]
    }

    func size(_ width: CGFloat, _ height: CGFloat) -> [NSLayoutConstraint] {
        return [
            widthAnchor.constraint(equalToConstant: width),
            heightAnchor.constraint(equalToConstant: height)
        ]
    }

    func addSubviews(_ views: [UIView]) {
        views.forEach {
            addSubview($0)
        }
    }
}

import WebKit
import SafariServices

final class WebViewHandler: NSObject, WKNavigationDelegate {
    var show: ((UIViewController) -> Void)?
    let supportedSchemes = ["http", "https"]

    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
        defer {
            decisionHandler(.allow)
        }

        guard
            navigationAction.navigationType == .linkActivated,
            let url = navigationAction.request.url,
            let scheme = url.scheme,
            supportedSchemes.contains(scheme)
        else {
            return
        }

        let controller = SFSafariViewController(url: url)
        show?(controller)
    }
}

import UIKit
import GoogleMaps
import Stripe

final class AppFlowController: UIViewController {
    private lazy var window = UIWindow(frame: UIScreen.main.bounds)

    func configure() {
        GMSServices.provideAPIKey(Constant.googleMapsApiKey)
        STPPaymentConfiguration.shared().publishableKey = Constant.stripeKey
    }

    func start() {
        if Deps.onboardingHandler.hasOnboarded {
            startMain()
        } else {
            startOnboarding()
        }

        window.makeKeyAndVisible()
    }

    func startOnboarding() {
        let controller = OnboardingController()
        controller.delegate = self
        window.rootViewController = controller
    }

    func startMain() {
        let controller = MainFlowController()
        window.rootViewController = controller
        controller.start()
    }
}

extension AppFlowController: OnboardingControllerDelegate {
    func onboardingControllerDidFinish(_ controller: OnboardingController) {
        Deps.onboardingHandler.hasOnboarded = true
        startMain()
    }
}

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    private let appFlowController = AppFlowController()

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        appFlowController.configure()
        appFlowController.start()

        UIApplication.shared.registerForRemoteNotifications()
		FirebaseApp.configure()
        return true
    }
}