URLSession.shared
.dataTaskPublisher(for: url)
.map({ $0.data })
.decode(type: T.self, decoder: JSONDecoder())
.eraseToAnyPublisher()
.receive(on: RunLoop.main)
.sink(receiveCompletion: { completionStatus in
    switch completionStatus {
    case .finished:
        break
    case .failure(let error):
        completion(.failure(error))
    }
}, receiveValue: { value in
    completion(.success(value))
})

let task = URLSession.shared.dataTask(with: url, completionHandler: { data, response, error in
    if let data = data, let model = try? JSONDecoder().decode(T.self, from: data) {
        completion(.success(model))
    } else {
        completion(.failure(error ?? ServiceError.noInternet))
    }
})

task.resume()

open class SpekTestCase: SpekHelperTestCase {
    open class func makeDescribe() -> Describe {
        return Describe("empty")
    }

    #if canImport(SpekHelper)

    override public class func spekGenerateTestMethodNames() -> [String] {
        let describe = Self.makeDescribe()

        var names: [String] = []
        generate(describe: describe, names: &names)
        return names
    }

    private static func addInstanceMethod(name: String, closure: @escaping () -> Void) -> String {
        let block: @convention(block) (SpekTestCase) -> Void = { spekTestCase in
            let _ = spekTestCase
            closure()
        }

        let implementation = imp_implementationWithBlock(block as Any)
        let selector = NSSelectorFromString(name)
        class_addMethod(self, selector, implementation, "v@:")

        return name
    }
}

targets: {
        var targets: [Target] = [
            .testTarget(
                name: "QuickTests",
                dependencies: [ "Quick", "Nimble" ],
                exclude: [
                    "QuickAfterSuiteTests/AfterSuiteTests+ObjC.m",
                    "QuickFocusedTests/FocusedTests+ObjC.m",
                    "QuickTests/FunctionalTests/ObjC",
                    "QuickTests/Helpers/QCKSpecRunner.h",
                    "QuickTests/Helpers/QCKSpecRunner.m",
                    "QuickTests/Helpers/QuickTestsBridgingHeader.h",
                    "QuickTests/QuickConfigurationTests.m",
                ]
            ),
        ]
#if os(macOS)
        targets.append(contentsOf: [
            .target(name: "QuickSpecBase", dependencies: []),
            .target(name: "Quick", dependencies: [ "QuickSpecBase" ]),
        ])
#else
        targets.append(contentsOf: [
            .target(name: "Quick", dependencies: []),
        ])
#endif
        return targets
    }(),

@available(iOS 11.0, *)
override func viewSafeAreaInsetsDidChange() {
    super.viewSafeAreaInsetsDidChange()

    self.collectionView.reloadData()
}

view.safeAreaLayoutGuide.layoutFrame

collectionView.superview?.superview?.safeAreaInsets

override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransition(to: size, with: coordinator)
    coordinator.animate(alongsideTransition: { _ in
        self.collectionViewLayout.invalidateLayout()
    })
}

// UIViewController subclass
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransition(to: size, with: coordinator)
    coordinator.animate(alongsideTransition: { _ in
        DispatchQueue.main.async {
            self.collectionViewLayout.invalidateLayout()
        }
    })
}

// UIPresentationController subclass
override var frameOfPresentedViewInContainerView: CGRect {
    guard let containerView = containerView else { return .zero }
    
    presentedView?.setNeedsLayout()
    presentedView?.layoutIfNeeded()

    return ...

func initialLayoutAttributesForAppearingDecorationElement(ofKind elementKind: String, at decorationIndexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
    return nil
}

func finalLayoutAttributesForDisappearingDecorationElement(ofKind elementKind: String, at decorationIndexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
    return nil
}

import UIKit

var mapping: [String: (UIViewController) -> Void] = [:]
var hasSwizzled = false

public func track<T: UIViewController>(_ type: T.Type, block: @escaping (T) -> Void) {
  let original = #selector(UIViewController.viewDidAppear(_:))
  let swizled = #selector(UIViewController.trackers_viewDidAppear(_:))

  if !hasSwizzled {
    swizzle(kClass: UIViewController.self, originalSelector: original, swizzledSelector: swizled)
    hasSwizzled = true
  }

  mapping[NSStringFromClass(type)] = { controller in
    if let controller = controller as? T {
      block(controller)
    }
  }
}

extension UIViewController {
  func trackers_viewDidAppear(_ animated: Bool) {
    trackers_viewDidAppear(animated)

    let string = NSStringFromClass(type(of: self))
    mapping[string]?(self)
  }
}

func swizzle(kClass: AnyClass, originalSelector: Selector, swizzledSelector: Selector) {
  let originalMethod = class_getInstanceMethod(kClass, originalSelector)
  let swizzledMethod = class_getInstanceMethod(kClass, swizzledSelector)

  let didAddMethod = class_addMethod(kClass, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod))

  if didAddMethod {
    class_replaceMethod(kClass, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod))
  } else {
    method_exchangeImplementations(originalMethod, swizzledMethod)
  }
}

track(ListController.self) {
  print("list controller has appeared")
}

track(DetailController.self) {
  print("detail controller has appeared")
}

track(CouponController.self) { controller in
  print("coupon controller has appeared with code \(controller.coupon.code)")
}

import UIKit

public protocol AdapterDelegate: class {

  /// Apply model to view
  func configure(model: Any, view: UIView, indexPath: IndexPath)

  /// Handle view selection
  func select(model: Any)

  /// Size the view
  func size(model: Any, containerSize: CGSize) -> CGSize
}

/// Act as DataSource and Delegate for UICollectionView, UITableView
open class Adapter: NSObject,
  UICollectionViewDataSource, UICollectionViewDelegateFlowLayout,
UITableViewDataSource, UITableViewDelegate {

  public var sections: [Section] = []
  public weak var collectionView: UICollectionView?
  public weak var tableView: UITableView?
  public weak var delegate: AdapterDelegate?

  let registryService = RegistryService()

  // MARK: - Initialiser
  public required init(collectionView: UICollectionView) {
    self.collectionView = collectionView
    super.init()
  }

  public required init(tableView: UITableView) {
    self.tableView = tableView
    super.init()
  }

  // MARK: - UICollectionViewDataSource
  open func numberOfSections(in collectionView: UICollectionView) -> Int {
    return sections.count
  }

  open func collectionView(_ collectionView: UICollectionView,
                           numberOfItemsInSection section: Int) -> Int {
    return sections[section].items.count
  }

  open func collectionView(_ collectionView: UICollectionView,
                           cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
    let item = sections[indexPath.section].items[indexPath.row]
    let cell = collectionView.dequeueReusableCell(
      withReuseIdentifier: item.cellType.typeName,
      for: indexPath)

    delegate?.configure(model: item.model, view: cell, indexPath: indexPath)

    return cell
  }

  open func collectionView(
    _ collectionView: UICollectionView,
    viewForSupplementaryElementOfKind kind: String,
    at indexPath: IndexPath) -> UICollectionReusableView {

    if let header = sections[indexPath.section].header,
      kind == UICollectionElementKindSectionHeader {

      let view = collectionView.dequeueReusableSupplementaryView(
        ofKind: UICollectionElementKindSectionHeader,
        withReuseIdentifier: header.viewType.typeName,
        for: indexPath
      )

      delegate?.configure(model: header.model, view: view, indexPath: indexPath)
      return view
    } else if let footer = sections[indexPath.section].footer,
      kind == UICollectionElementKindSectionFooter {

      let view = collectionView.dequeueReusableSupplementaryView(
        ofKind: UICollectionElementKindSectionFooter,
        withReuseIdentifier: footer.viewType.typeName,
        for: indexPath
      )

      delegate?.configure(model: footer.model, view: view, indexPath: indexPath)
      return view
    } else {
      let view = DummyReusableView()
      view.isHidden = true
      return view
    }
  }

  // MARK: - UICollectionViewDelegate
  open func collectionView(
    _ collectionView: UICollectionView,
    didSelectItemAt indexPath: IndexPath) {

    let item = sections[indexPath.section].items[indexPath.row]
    delegate?.select(model: item.model)
    collectionView.deselectItem(at: indexPath, animated: true)
  }

  open func collectionView(
    _ collectionView: UICollectionView,
    layout collectionViewLayout: UICollectionViewLayout,
    sizeForItemAt indexPath: IndexPath) -> CGSize {

    let item = sections[indexPath.section].items[indexPath.row]
    if let size = delegate?.size(model: item.model, containerSize: collectionView.frame.size) {
      return size
    }

    if let size = (collectionViewLayout as? UICollectionViewFlowLayout)?.itemSize {
      return size
    }

    return collectionView.frame.size
  }

  open func collectionView(
    _ collectionView: UICollectionView,
    layout collectionViewLayout: UICollectionViewLayout,
    referenceSizeForHeaderInSection section: Int) -> CGSize {

    guard let header = sections[section].header else {
      return .zero
    }

    guard let size = delegate?.size(model: header.model, containerSize: collectionView.frame.size) else {
      return .zero
    }

    return size
  }

  open func collectionView(
    _ collectionView: UICollectionView,
    layout collectionViewLayout: UICollectionViewLayout,
    referenceSizeForFooterInSection section: Int) -> CGSize {

    guard let footer = sections[section].footer else {
      return .zero
    }

    guard let size = delegate?.size(model: footer.model, containerSize: collectionView.frame.size) else {
      return .zero
    }

    return size
  }

  // MARK: - Reload
  open func reload(sections: [Section]) {
    // Registry
    registryService.registerIfNeeded(
      collectionView: collectionView,
      tableView: tableView,
      sections: sections
    )

    self.sections = sections
    collectionView?.reloadData()
    tableView?.reloadData()
  }

  // MARK: - UITableViewDataSource
  open func numberOfSections(in tableView: UITableView) -> Int {
    return sections.count
  }

  open func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return sections[section].items.count
  }

  open func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let item = sections[indexPath.section].items[indexPath.row]
    let cell = tableView.dequeueReusableCell(
      withIdentifier: item.cellType.typeName,
      for: indexPath
    )

    delegate?.configure(model: item.model, view: cell, indexPath: indexPath)

    return cell
  }

  // MARK: - UITableViewDelegate
  open func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let item = sections[indexPath.section].items[indexPath.row]
    delegate?.select(model: item.model)
    tableView.deselectRow(at: indexPath, animated: true)
  }

  open func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
    let item = sections[indexPath.section].items[indexPath.row]
    if let size = delegate?.size(model: item.model, containerSize: tableView.frame.size) {
      return size.height
    }

    return 0
  }

  open func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
    guard let header = sections[section].header else {
      return 0
    }

    guard let size = delegate?.size(model: header.model, containerSize: tableView.frame.size) else {
      return 0
    }

    return size.height
  }

  open func tableView(_ tableView: UITableView, heightForFooterInSection section: Int) -> CGFloat {
    guard let footer = sections[section].footer else {
      return 0
    }

    guard let size = delegate?.size(model: footer.model, containerSize: tableView.frame.size) else {
      return 0
    }

    return size.height
  }

  open func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
    guard let header = sections[section].header else {
      return nil
    }

    guard let view = tableView.dequeueReusableHeaderFooterView(withIdentifier: header.viewType.typeName) else {
      return nil
    }

    delegate?.configure(model: header.model, view: view, indexPath: IndexPath(row: 0, section: section))
    return view
  }

  open func tableView(_ tableView: UITableView, viewForFooterInSection section: Int) -> UIView? {
    guard let footer = sections[section].footer else {
      return nil
    }

    guard let view = tableView.dequeueReusableHeaderFooterView(withIdentifier: footer.viewType.typeName) else {
      return nil
    }

    delegate?.configure(model: footer.model, view: view, indexPath: IndexPath(row: 0, section: section))
    return view
  }
}

let sections: [Section] = [
  Section(
    header: Header(model: Model.header("Information"), viewType: HeaderView.self),
    items: [
      Item(model: Model.avatar(avatarUrl), cellType: AvatarCell.self),
      Item(model: Model.name("Thor"), cellType: NameCell.self),
      Item(model: Model.location("Asgard"), cellType: NameCell.self)
    ]
  ),
  Section(
    header: Header(model: Model.header("Skills"), viewType: HeaderView.self),
    items: [
      Item(model: Model.skill("iOS"), cellType: SkillCell.self),
      Item(model: Model.skill("Android"), cellType: SkillCell.self)
    ]
  )
]

adapter.reload(sections: sections)

extension ProfileViewController: AdapterDelegate {
  func configure(model: Any, view: UIView, indexPath: IndexPath) {
    guard let model = model as? Model else {
      return
    }

    switch (model, view) {
    case (.avatar(let string), let cell as Avatarcell):
      cell.configure(string: string)
    case (.name(let name), let cell as NameCell):
      cell.configure(string: name)
    case (.header(let string), let view as HeaderView):
      view.configure(string: string)
    default:
      break
    }
  }

  func select(model: Any) {
    guard let model = model as? Model else {
      return
    }

    switch model {
    case .skill(let skill):
      let skillController = SkillController(skill: skill)
      navigationController?.pushViewController(skillController, animated: true)
    default:
      break
    }
  }

  func size(model: Any, containerSize: CGSize) -> CGSize {
    guard let model = model as? Model else {
      return .zero
    }

    switch model {
    case .name:
      return CGSize(width: containerSize.width, height: 40)
    case .avatar:
      return CGSize(width: containerSize.width, height: 200)
    case .header:
      return CGSize(width: containerSize.width, height: 30)
     default:
       return .zero
    }
  }
}

class AccordionManager<T>: Manager<T> {
  private var collapsedSections = Set<Int>()
 
  override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return collapsedSections.contains(section)
      ? 0 : sections[section].items.count
  }
 
  func toggle(section: Int) {
    if collapsedSections.contains(section) {
      collapsedSections.remove(section)
    } else {
      collapsedSections.insert(section)
    }
 
    let indexSet = IndexSet(integer: section)
    tableView?.reloadSections(indexSet, with: .automatic)
  }
}

public class HUDContainer: UIVisualEffectView, AnimationAware {
    private let innerContentView: UIView & AnimationAware
    public let label = UILabel()
    public var text: String? {
        didSet {
            label.text = text
            label.sizeToFit()
            label.isHidden = text == nil
        }
    }

    public init(contentView: UIView & AnimationAware) {
        self.innerContentView = contentView
        super.init(effect: UIBlurEffect(style: .light))
        self.contentView.addSubview(innerContentView)
        self.contentView.addSubview(label)

        innerContentView.pinEdgesToSuperview()
        configure()
    }

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

    public func configure() {
        layer.cornerRadius = 8
        layer.masksToBounds = true

        label.isHidden = false
        label.font = UIFont.preferredFont(forTextStyle: .body)
        label.textColor = UIColor.black
        label.textAlignment = .center
        label.translatesAutoresizingMaskIntoConstraints = false

        NSLayoutConstraint.activate([
            label.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -8),
            label.leftAnchor.constraint(equalTo: contentView.leftAnchor, constant: 10),
            label.rightAnchor.constraint(equalTo: contentView.rightAnchor, constant: -10),
        ])
    }

    public func startAnimation() {
        innerContentView.startAnimation()
    }

    public func endAnimation() {
        innerContentView.stopAnimation()
    }
}

import UIKit

public class ErrorView: UIView, AnimationAware {
    public let line1 = CAShapeLayer()
    public let line2 = CAShapeLayer()

    public let animation1 = CASpringAnimation(keyPath: #keyPath(CALayer.transform))
    public let animation2 = CASpringAnimation(keyPath: #keyPath(CALayer.transform))

    public var lineColor: UIColor = UIColor.darkGray
    public var duration: TimeInterval = 0.75

    public override init(frame: CGRect) {
        super.init(frame: frame)
        layer.addSublayer(line1)
        layer.addSublayer(line2)
        configure()
    }

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

    public override func layoutSubviews() {
        super.layoutSubviews()

        configureSize()
    }

    public func configure() {
        [line1, line2].forEach {
            $0.backgroundColor = lineColor.cgColor
        }

        [animation1, animation2].forEach {
            $0.fromValue = 0
            $0.damping = 0.33
            $0.initialVelocity = 0.01
            $0.mass = 0.2
            $0.duration = duration
            $0.valueFunction = CAValueFunction(name: CAValueFunctionName.rotateZ)
            $0.timingFunction = CAMediaTimingFunction(name: .easeIn)
        }

        animation1.toValue = CGFloat.pi / 4
        animation2.toValue = -CGFloat.pi / 4
    }

    private func configureSize() {
        guard line1.frame.width <= 0 else {
            return
        }

        [line1, line2].forEach {
            $0.cornerRadius = 3
            $0.frame.size = CGSize(width: bounds.width*0.6, height: 6)
            $0.position = layer.position
        }
    }

    public override func didMoveToWindow() {
        super.didMoveToWindow()

        line1.transform = CATransform3DIdentity
        line2.transform = CATransform3DIdentity
    }

    public func startAnimation() {
        line1.transform = CATransform3DMakeRotation(CGFloat.pi/4, 0, 0, 1.0)
        line2.transform = CATransform3DMakeRotation(-CGFloat.pi/4, 0, 0, 1.0)

        line1.add(animation1, forKey: nil)
        line2.add(animation2, forKey: nil)
    }

    public func stopAnimation() {
        line1.removeAllAnimations()
        line2.removeAllAnimations()
    }
}

import UIKit

public class ProgressView: UIView, AnimationAware {
    public let replicatorLayer = CAReplicatorLayer()
    public let animation = CABasicAnimation(keyPath: #keyPath(CALayer.opacity))
    public let line = CALayer()

    public var lineCount: Int = 12
    public var duration: TimeInterval = 1.0
    public var lineSize: CGSize = CGSize(width: 20, height: 6)
    public var lineColor: UIColor = UIColor.darkGray

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

        configure()
    }

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

    public func configure() {
        let angle = CGFloat.pi * 2 / CGFloat(lineCount)
        let rotation = CATransform3DMakeRotation(angle, 0, 0, 1.0)

        replicatorLayer.instanceTransform = rotation
        replicatorLayer.instanceCount = lineCount
        replicatorLayer.instanceDelay = duration / TimeInterval(lineCount)

        line.backgroundColor = lineColor.cgColor
        line.frame.size = lineSize
        line.cornerRadius = lineSize.height / 2

        animation.fromValue = 1.0
        animation.toValue = 0.0
        animation.repeatCount = Float.greatestFiniteMagnitude
        animation.timingFunction = CAMediaTimingFunction(name: .linear)
        animation.duration = duration

        replicatorLayer.addSublayer(line)
        layer.addSublayer(replicatorLayer)

        // x: the larger, the closer to center
        // y: half the height, changing affects rotation of lines
        line.position = CGPoint(x: 48, y: 75)
    }

    public override func layoutSubviews() {
        super.layoutSubviews()

        replicatorLayer.frame = bounds
    }

    public func startAnimation() {
        line.add(animation, forKey: nil)
    }

    public func stopAnimation() {
        line.removeAllAnimations()
    }
}

import UIKit

public class SuccessView: UIView, AnimationAware {
    public let shapeLayer = CAShapeLayer()
    public let animation = CABasicAnimation(keyPath: #keyPath(CAShapeLayer.strokeEnd))

    public var lineColor: UIColor = UIColor.darkGray
    public var duration: TimeInterval = 0.25

    public override init(frame: CGRect) {
        super.init(frame: frame)
        layer.addSublayer(shapeLayer)
        configure()
    }

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

    public override func layoutSubviews() {
        super.layoutSubviews()

        configurePath()
    }

    public func configure() {
        shapeLayer.lineCap = .round
        shapeLayer.lineJoin = .round
        shapeLayer.fillColor = nil
        shapeLayer.strokeColor = lineColor.cgColor
        shapeLayer.lineWidth = 6

        animation.timingFunction = CAMediaTimingFunction(name: .easeIn)
        animation.fromValue = 0.0
        animation.toValue = 1.0
        animation.duration = duration
    }

    private func configurePath() {
        let size = CGSize(width: 80, height: 60)
        shapeLayer.frame = CGRect(origin: .zero, size: size)
        shapeLayer.position = layer.position

        let path = UIBezierPath()
        path.move(to: CGPoint(x: size.width * 0, y: size.height * 0.48))
        path.addLine(to: CGPoint(x: size.width * 0.38, y: size.height))
        path.addLine(to: CGPoint(x: size.width, y: size.height * 0.01))

        shapeLayer.path = path.cgPath
    }

    public override func didMoveToWindow() {
        super.didMoveToWindow()

        shapeLayer.strokeEnd = 0.0
    }

    public func startAnimation() {
        shapeLayer.strokeEnd = 1.0
        shapeLayer.add(animation, forKey: nil)
    }

    public func stopAnimation() {
        shapeLayer.removeAllAnimations()
    }
}

// swift-tools-version:5.1
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription

let package = Package(
    name: "PumaSwiftWeb",
    dependencies: [
        .package(url: "https://github.com/johnsundell/publish.git", from: "0.1.0")
    ],
    targets: [
        .target(
            name: "PumaSwiftWeb",
            dependencies: [
            	"Publish"
        	]
        )
    ]
)

import Publish
import Plot
import Ink
import Foundation

struct PumaSwiftWeb: Website {
    enum SectionID: String, WebsiteSectionID {
        case gettingStarted
        case workflow
        case tasks
        case about
    }

    struct ItemMetadata: WebsiteItemMetadata {}

    var url = URL(string: "https://pumaswift.github.io")!
    var name = "Puma Swift"
    var description = "Build utilities in pure Swift"
    var language: Language { .english }
    var imagePath: Path? { "https://avatars2.githubusercontent.com/u/54233247?s=200&v=4" }
}

try PumaSwiftWeb()
    .publish(withTheme: .foundation)

public struct Transporter {
    var arguments: [String] = []

    func run(workflow: Workflow) throws {
        guard Folder.directoryExists(path: "/Applications/Transporter.app") else {
            Deps.console.warn("You need to install Transporter")
            throw PumaError.invalid
        }

        try CommandLine().runBash(
            workflow: workflow,
            program: transportPath(),
            arguments: arguments
        )
    }

    private func transportPath() throws -> String {
        if Folder.directoryExists(path: "/Applications/Transporter.app") {
            return "/Applications/Transporter.app/Contents/itms/bin/iTMSTransporter"
        } else if Folder.directoryExists(path: "/Applications/Xcode.app/Contents/Applications/Application Loader.app/") {
            return "/Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/MacOS/itms/bin/iTMSTransporter"
        } else {
            throw PumaError.invalid
        }
    }
}

Timer.scheduledTimer(withTimeInterval: seconds, repeats: false, block: { _ in
    completion(.success(()))
})

RunLoop.current.run()

import Foundation

public class Slack {
    public var name: String = "Send message to Slack"
    public var isEnabled = true

    private var message: Message?

    public init(_ closure: (Slack) -> Void = { _ in }) {
        closure(self)
    }
}

public extension Slack {
    struct Message {
        let token: String
        let channel: String
        let text: String
        let username: String?

        public init(
            token: String,
            channel: String,
            text: String,
            username: String
        ) {
            self.token = token
            self.channel = channel
            self.text = text
            self.username = username
        }
    }

    func post(message: Message) {
        self.message = message
    }
}

extension Slack: Task {
    public func run(workflow: Workflow, completion: @escaping TaskCompletion) {
        guard let message = message else {
            completion(.failure(PumaError.invalid))
            return
        }

        let sender = MessageSender()
        sender.send(message: message, completion: { result in
            switch result {
            case .success:
                Deps.console.success("Message posted successfully")
            case .failure(let error):
                Deps.console.error("Failed: \(error.localizedDescription)")
            }
            completion(result)
        })
    }
}

private class MessageSender {
    struct Response: Decodable {
        let ok: Bool
        let error: String?
    }

    func send(message: Slack.Message, completion: @escaping (Result<(), Error>) -> Void) {
        guard let baseUrl = URL(string: "https://slack.com/api/chat.postMessage") else {
            completion(.failure(PumaError.invalid))
            return
        }

        var components = URLComponents(url: baseUrl, resolvingAgainstBaseURL: false)
        components?.queryItems = [
            URLQueryItem(name: "token", value: message.token),
            URLQueryItem(name: "channel", value: message.channel),
            URLQueryItem(name: "text", value: message.text),
            URLQueryItem(name: "pretty", value: "1")
        ]

        if let username = message.username {
            components?.queryItems?.append(
                URLQueryItem(name: "username", value: username)
            )
        }

        guard let requestUrl = components?.url else {
            completion(.failure(PumaError.invalid))
            return
        }

        var request = URLRequest(url: requestUrl)
        request.allHTTPHeaderFields = [
            "Accept": "application/json"
        ]

        let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
            guard let data = data else {
                completion(.failure(error ?? PumaError.invalid))
                return
            }

            do {
                let response = try JSONDecoder().decode(Response.self, from: data)
                if response.ok {
                    completion(.success(()))
                } else {
                    completion(.failure(PumaError.from(string: response.error)))
                }
            } catch {
                completion(.failure(error))
            }
        })

        task.resume()
    }
}

public class GetDestinations {
    public init() {}

    public func getAvailable(workflow: Workflow) throws -> [Destination] {
        let processHandler = DefaultProcessHandler(filter: { $0.starts(with: "name=") })
        let string = try CommandLine().runBash(
            workflow: workflow,
            program: "xcrun simctl",
            arguments: [
                "list",
                "devices",
                "-j"
            ],
            processHandler: processHandler
        )

        guard let data = string.data(using: .utf8) else {
            throw PumaError.invalid
        }

        let response: Response = try JSONDecoder().decode(Response.self, from: data)
        let devicesWithOS: [DeviceWithOS] = response.devices.flatMap({ key, value in
            return value.map({ DeviceWithOS(device: $0, os: key) })
        })

        let destinations: [Destination] = try devicesWithOS
            .filter({ withOS in
                return withOS.device.isAvailable
            })
            .compactMap({ withOS in
                guard
                    let platform = self.platform(withOS: withOS),
                    let os = try self.os(withOS: withOS)
                else {
                    return  nil
                }

                var destination = Destination(
                    name: withOS.device.name,
                    platform: platform,
                    os: os
                )
                destination.id = withOS.device.udid
                return destination
            })

        return destinations
    }

    func findId(workflow: Workflow, destination: Destination) throws -> String? {
        let availableDestinations = try self.getAvailable(workflow: workflow)
        return availableDestinations.first(where: { $0 == destination })?.id
    }

    // MARK: - Private

    private func platform(withOS: DeviceWithOS) -> String? {
        let list: [String] = [
            Destination.Platform.iOS,
            Destination.Platform.watchOS,
            Destination.Platform.macOS,
            Destination.Platform.tvOS,
        ]

        return list.first(where: { withOS.os.contains($0) })
    }

    // com.apple.CoreSimulator.SimRuntime.iOS-13-2
    private func os(withOS: DeviceWithOS) throws -> String? {
        guard let string = try withOS.os.matches(pattern: #"(-\d+)+"#).first else {
            return nil
        }

        return string.dropFirst().replacingOccurrences(of: "-", with: ".")
    }
}

private struct Response: Decodable {
    let devices: [String: [Device]]
}

private struct Device: Decodable {
    let state: String
    let name: String
    let udid: String
    let isAvailable: Bool
}

private struct DeviceWithOS {
    let device: Device
    let os: String
}

public class GetDestinations {
    public init() {}

    public func getAvailable(workflow: Workflow) throws -> [Destination] {
        let processHandler = DefaultProcessHandler(filter: { $0.starts(with: "name=") })
        let string = try CommandLine().runBash(
            workflow: workflow,
            program: "xcrun instruments",
            arguments: [
                "-s",
                "devices"
            ],
            processHandler: processHandler
        )

        // Ex: iPad Air (11.0.1) [7A5EAD29-D870-49FB-9A9B-C81079620AC9] (Simulator)
        let destinations: [Destination] = try string
            .split(separator: "\n")
            .map({ String($0) })
            .filter({ try $0.hasPattern(pattern: #"\[.+\]"#) })
            .compactMap({ (line) -> Destination? in
                parse(line)
            })

        return destinations
    }

    func parse(_ line: String) -> Destination? {
        guard var id = try? line.matches(pattern: #"\[.+\]"#).first else {
            return nil
        }

        var line = line
        line = line.replacingOccurrences(of: id, with: "")
        id = id
            .replacingOccurrences(of: "[", with: "")
            .replacingOccurrences(of: "]", with: "")

        let isSimulator = line.contains("(Simulator)")
        line = line.replacingOccurrences(of: "(Simulator)", with: "")

        var os = (try? line.matches(pattern: #"\((\d+\.)?(\d+\.)?(\*|\d+)\)"#).first) ?? ""
        let name = line
            .replacingOccurrences(of: os, with: "")
            .trimmingCharacters(in: .whitespacesAndNewlines)

        os = os.replacingOccurrences(of: "(", with: "")
            .replacingOccurrences(of: ")", with: "")

        let device = self.device(name: name)

        if os.isEmpty {
            return Destination(name: name, id: id)
        } else {
            let platform = isSimulator ? "\(device) Simulator" : device
            return Destination(name: name, platform: platform, os: os)
        }
    }

    // MARK: - Private

    private func device(name: String) -> String {
        if name.starts(with: "iPad") || name.starts(with: "iPhone") {
            return Destination.Platform.iOS
        } else if name.starts(with: "Apple Watch") {
            return Destination.Platform.watchOS
        } else if name.starts(with: "Apple TV") {
            return Destination.Platform.tvOS
        } else if name.containsIgnoringCase("mac") {
            return Destination.Platform.macOS
        } else {
            return Destination.Platform.iOS
        }
    }
}

ProcessInfo().environment["username"]

import Foundation

public protocol XmlItem {
    func toLines() -> [String]
}

public struct XmlString: XmlItem {
    public let key: String
    public let value: String

    public init(key: String, value: String) {
        self.key = key
        self.value = value
    }

    public func toLines() -> [String] {
        return [
            "<key>\(key)</key>",
            "<string>\(value)</string>"
        ] as [String]
    }
}

public struct XmlBool: XmlItem {
    public let key: String
    public let value: Bool

    public init(key: String, value: Bool) {
        self.key = key
        self.value = value
    }

    public func toLines() -> [String] {
        let string = value ? "<true/>" : "<false/>"
        return [
            "<key>\(key)</key>",
            "\(string)"
        ] as [String]
    }
}

public struct XmlDict: XmlItem {
    public let key: String
    public let items: [XmlItem]

    public init(key: String, items: [XmlItem]) {
        self.key = key
        self.items = items
    }

    public func toLines() -> [String] {
        var lines = [String]()
        lines.append("<dict>")
        lines.append(contentsOf: items.flatMap({ $0.toLines() }))
        lines.append("</dict>")

        return lines
    }
}

public class XmlGenerator {
    public init() {}
    public func generateXml(_ items: [XmlItem]) -> String {
        let content = items.flatMap({ $0.toLines() }).joined(separator: "\n")
        let xml =
        """
        <?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
        <plist version="1.0">
        <dict>
        \(content)
        </dict>
        </plist>
        """
        return xml
    }

    public func xmlItems(dictionary: [String: Any]) -> [XmlItem] {
        return dictionary.flatMap({ (key, value) -> [XmlItem] in
            switch value {
            case let string as String:
                return [XmlString(key: key, value: string)]
            case let bool as Bool:
                return [XmlBool(key: key, value: bool)]
            case let nestedDictionary as [String: Any]:
                return xmlItems(dictionary: nestedDictionary)
            default:
                return []
            }
        })
    }
}