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

Bundle.main.path(forResource: "ffmpeg", ofType: "")!

import Foundation

protocol TaskDelegate: class {
  func task(task: Task, didOutput string: String)
  func taskDidComplete(task: Task)
}

class Task {

  weak var delegate: TaskDelegate?
  let process = Process()

  func run(arguments: [String]) {
    DispatchQueue.background.async {
      let launchPath = Bundle.main.path(forResource: "executable", ofType: "")!
      self.run(launchPath: launchPath, arguments: arguments)
    }
  }

  func stop() {
    DispatchQueue.background.async {
      if self.process.isRunning {
        self.process.terminate()
      }
    }
  }

  // MARK: - Helper

  private func run(launchPath: String, arguments: [String]) {
    let process = Process()
    process.launchPath = launchPath
    process.arguments = arguments

    let stdOut = Pipe()
    process.standardOutput = stdOut
    let stdErr = Pipe()
    process.standardError = stdErr

    let handler =  { [weak self] (file: FileHandle!) -> Void in
      let data = file.availableData
      guard let output = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else {
        return
      }

      guard let strongSelf = self,
        let string = output.components(separatedBy: "\n").first else {
        return
      }

      DispatchQueue.main.async {
        strongSelf.delegate?.task(task: strongSelf, didOutput: string)
      }
    }

    stdErr.fileHandleForReading.readabilityHandler = handler
    stdOut.fileHandleForReading.readabilityHandler = handler

    process.terminationHandler = { [weak self] (task: Process?) -> () in
      stdErr.fileHandleForReading.readabilityHandler = nil
      stdOut.fileHandleForReading.readabilityHandler = nil

      guard let strongSelf = self else {
        return
      }

      DispatchQueue.main.async {
        strongSelf.delegate?.taskDidComplete(task: strongSelf)
      }
    }

    process.launch()
    process.waitUntilExit()
  }
}

let process = Process()
process.launchPath = "/bin/pwd"
process.arguments = []

let popover = NSPopover()
popover.appearance = NSAppearance(named: NSAppearance.Name.aqua)

import AppKit
import Anchors
import Omnia

final class ScrollableStackView: NSView {
    final class FlippedClipView: NSClipView {
        override var isFlipped: Bool {
            return true
        }
    }

    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)
        setup()
    }

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

    let stackView: NSStackView = withObject(NSStackView()) {
        $0.orientation = .vertical
    }

    private let scrollView: NSScrollView = NSScrollView()

    private func setup() {
        addSubview(scrollView)
        scrollView.hasVerticalScroller = true
        scrollView.drawsBackground = false

        activate(
            scrollView.anchor.edges
        )

        let clipView = FlippedClipView()
        clipView.translatesAutoresizingMaskIntoConstraints = false

        clipView.drawsBackground = false
        scrollView.contentView = clipView

        activate(
            clipView.anchor.edges.equal.to(scrollView.anchor)
        )

        scrollView.documentView = stackView
        stackView.translatesAutoresizingMaskIntoConstraints = false
        activate(
            clipView.anchor.left.top.right.equal.to(stackView.anchor)
        )
    }
}

var views: NSArray?
NSNib(nibNamed: NSNib.Name("ProfileView"), bundle: nil)?.instantiate(withOwner: nil, topLevelObjects: &views)
let profileView = views!.compactMap({ $0 as? ProfileView }).first!

import AppKit

final class QRCodeGenerator {
  func generate(string: String, size: CGSize) -> NSImage? {
    guard let data = string.data(using: .utf8) else {
      return nil
    }

    // Filter
    guard let filter = CIFilter(name: "CIQRCodeGenerator") else {
      return nil
    }

    filter.setValue(data, forKey: "inputMessage")
    filter.setValue("Q", forKey: "inputCorrectionLevel")

    // CIImage
    guard let ciImage = filter.outputImage else {
      return nil
    }

    // NSImage
    let rep = NSCIImageRep(ciImage: ciImage)
    let image = NSImage(size: rep.size)
    image.addRepresentation(rep)

    // Scale
    let finalImage = NSImage(size: size)
    finalImage.lockFocus()
    NSGraphicsContext.current?.imageInterpolation = .none
    image.draw(in: NSRect(origin: .zero, size: size))
    finalImage.unlockFocus()

    return finalImage
  }
}

let layout = NSCollectionViewFlowLayout()
layout.minimumLineSpacing = 4

collectionView = NSCollectionView()
collectionView.dataSource = self
collectionView.delegate = self
collectionView.collectionViewLayout = layout
collectionView.allowsMultipleSelection = false
collectionView.backgroundColors = [.clear]
collectionView.isSelectable = true
collectionView.register(
  Cell.self,
  forItemWithIdentifier: NSUserInterfaceItemIdentifier(rawValue: "Cell")
)

scrollView = NSScrollView()
scrollView.documentView = collectionView
view.addSubview(scrollView)

final class Cell: NSCollectionViewItem {
  let label = Label()
  let myImageView = NSImageView()

  override func loadView() {
    self.view = NSView()
    self.view.wantsLayer = true
  }
}

func collectionView(_ collectionView: NSCollectionView, numberOfItemsInSection section: Int) -> Int {
  return coins.count
}

func collectionView(_ collectionView: NSCollectionView, itemForRepresentedObjectAt indexPath: IndexPath) -> NSCollectionViewItem {
  let cell = collectionView.makeItem(
    withIdentifier: NSUserInterfaceItemIdentifier(rawValue: "Cell"),
    for: indexPath
  ) as! Cell

  let coin = coins[indexPath.item]

  cell.label.stringValue = coin.name
  cell.coinImageView.image =
    NSImage(named: NSImage.Name(rawValue: "USD"))
    ?? NSImage(named: NSImage.Name(rawValue: "Others"))

  return cell
}

func collectionView(_ collectionView: NSCollectionView, didSelectItemsAt indexPaths: Set<IndexPath>) {
    guard let indexPath = indexPaths.first,
    let cell = collectionView.item(at: indexPath) as? Cell else {
      return
  }
}

func collectionView(_ collectionView: NSCollectionView, didDeselectItemsAt indexPaths: Set<IndexPath>) {
  guard let indexPath = indexPaths.first,
    let cell = collectionView.item(at: indexPath) as? Cell else {
      return
  }
}

func collectionView(_ collectionView: NSCollectionView, layout collectionViewLayout: NSCollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> NSSize {

  return NSSize(
    width: collectionView.frame.size.width,
    height: 40
  )
}

let app = NSApplication.shared
let delegate = AppDelegate()
app.delegate = delegate
app.run()

final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
  let controller = IDETouchBarSimulatorHostWindowController.simulatorHostWindowController()!
  lazy var window: NSWindow = self.controller.window!
}

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

        return true
    }
}

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate {



    func applicationDidFinishLaunching(aNotification: NSNotification) {
        // Insert code here to initialize your application
    }

    func applicationWillTerminate(aNotification: NSNotification) {
        // Insert code here to tear down your application
    }
}