import UIKit

class AutomaticCitySelectionViewController: UIViewController {
    
    var tableData = []
    @IBOutlet weak var redditListTableView: UITableView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Call from e.g nib etc
        self.navigationItem.backBarButtonItem = UIBarButtonItem(title: "", style: UIBarButtonItemStyle.Bordered, target: nil, action: nil)
        //redditListTableView.frame.size.height = view.frame.height - self.navigationController?.navigationBar.frame.height
        getRestaurantsNearMe()
    }
    
    func getRestaurantsNearMe(function : String) {
        let mySession = NSURLSession.sharedSession()
        var redditUrl = "http://reddit.com/.json"
        let url = NSURL(string: redditUrl)
        let networkTask = mySession.dataTaskWithURL(url!, completionHandler : {data, response, error -> Void in
            var err: NSError?
            var theJSON = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.MutableContainers, error: &err) as NSMutableDictionary
            let results : NSArray = theJSON["data"]!["children"] as NSArray
            dispatch_async(dispatch_get_main_queue(), {
                self.tableData = results
                self.redditListTableView!.reloadData()
            })
        })
        networkTask.resume()
    }
        
    func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {
        return tableData.count
    }
        
    func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) -> UITableViewCell! {
        let cell: UITableViewCell = UITableViewCell(style: UITableViewCellStyle.Subtitle, reuseIdentifier: "MyTestCell")
        let redditEntry : NSMutableDictionary = self.tableData[indexPath.row] as NSMutableDictionary
        cell.textLabel?.text = redditEntry["data"]!["title"] as? String
        cell.detailTextLabel?.text = redditEntry["data"]!["author"] as? String
        return cell
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}

func randomFact() -> String {
    let randomFacts = [
        "The Tiger is the biggest species in the cat family",
        "Tigers can reach a length of 3.3 meters",
        "A group of tigers is known as an 'ambush' or 'streak'",
    ]

    let randomNumber = Int(arc4random_uniform(UInt32(randomFacts.count)))

    return randomFacts[randomNumber]
}

import UIKit

class Example : UIView{
  private var machine:StateMachine<Example>!
  enum TrafficLight{
    case Stop, Go, Caution
  }

  
  required init(coder aDecoder: NSCoder) {
    super.init(coder: aDecoder)
    machine = StateMachine(initialState: .Stop, delegate: self)
  }

  
  @IBAction func tappedGo(sender:AnyObject){
    machine.state = .Go
  }
  
  
  @IBAction func tappedCaution(sender:AnyObject){
    machine.state = .Caution
  }
}



extension Example : StateMachineDelegateProtocol{
  typealias StateType = TrafficLight

  
  func shouldTransitionFrom(from: StateType, to: StateType) -> Should<StateType> {
    switch (from, to){
    case (.Stop, .Go), (.Caution, .Stop):
      return .Continue
    case (.Go, .Caution):
      return .Redirect(.Stop)
    default:
      return .Abort
    }
  }
  
  
  func didTransitionFrom(from: StateType, to: StateType) {
    switch to{
    case .Stop:
      backgroundColor = UIColor.redColor()
    case .Go:
      backgroundColor = UIColor.greenColor()
    case .Caution:
      backgroundColor = UIColor.yellowColor()
    }
  }
}

import Foundation

class StateMachine<P:StateMachineDelegateProtocol>{
  private unowned let delegate:P

  private var _state:P.StateType{
    didSet{
      delegate.didTransitionFrom(oldValue, to:_state)
    }
  }

  var state:P.StateType{
    get{
      return _state
    }
    set{ //Can't be an observer because we need the option to CONDITIONALLY set state
      delegateTransitionTo(newValue)
    }
  }
  
  
  init(initialState:P.StateType, delegate:P){
    _state = initialState //set the primitive to avoid calling the delegate.
    self.delegate = delegate
  }
  
  
  private func delegateTransitionTo(to:P.StateType){
    switch delegate.shouldTransitionFrom(_state, to:to){
    case .Continue:
      _state = to
    case .Redirect(let newState):
      _state = to
      state = newState
    case .Abort:
      break;
    }
  }
}



protocol StateMachineDelegateProtocol: class{
  typealias StateType
  func shouldTransitionFrom(from:StateType, to:StateType)->Should<StateType>
  func didTransitionFrom(from:StateType, to:StateType)
}



enum Should<T>{
  case Continue, Abort, Redirect(T)
}

extension UIViewController {
    func topMostViewController() -> UIViewController {
        if self.presentedViewController == nil {
            return self
        }
        if let navigation = self.presentedViewController as? UINavigationController {
            return navigation.visibleViewController.topMostViewController()
        }
        if let tab = self.presentedViewController as? UITabBarController {
            if let selectedTab = tab.selectedViewController {
                return selectedTab.topMostViewController()
            }
            return tab.topMostViewController()
        }
        return self.presentedViewController!.topMostViewController()
    }
}

extension UIApplication {
    func topMostViewController() -> UIViewController? {
        return self.keyWindow?.rootViewController?.topMostViewController()
    }
}

import UIKit

private let scale = UIScreen.mainScreen().scale

class PixelConstraint: NSLayoutConstraint {
    override var constant: CGFloat {
        get { return super.constant / scale }
        set(value) { super.constant = value }
    }
}

import Darwin

extension Int {
    static func random() -> Int {
        return Int(arc4random())
    }

    static func random(range: Range<Int>) -> Int {
        return Int(arc4random_uniform(UInt32(range.endIndex - range.startIndex))) + range.startIndex
    }
}

extension Double {
    static func random() -> Double {
        return drand48()
    }
}

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
largest

var result: Unmanaged<AnyObject>?
SecItemCopyMatching(query, &result)

// Doesn't work on 32-bit platforms (probably due to compiler bug)
return result?.takeUnretainedValue() as? NSData

var alertController = UIAlertController(title: "あなたはシカオさんではありませんね？", message:"", preferredStyle: UIAlertControllerStyle.Alert)

let はいAlertAction = UIAlertAction(title: "はい", style: UIAlertActionStyle.Default, handler: {...(略)...})
let いいえAlertAction = UIAlertAction(title: "いいえ", style: UIAlertActionStyle.Cancel, handler: nil)

alertController.addAction(はいAlertAction)
alertController.addAction(いいえAlertAction)
self.presentViewController(alertController, animated: true, completion:nil)

import UIKit

class SegmentedControl: UIControl {
    private let action = Selector("selectSegment:")

    @IBOutlet
    private var segments: [UIButton] = [] {
        didSet {
            segments.sortInPlace { $0.tag < $1.tag }
            subscribe(segments)
        }
    }

    var selectedSegmentIndex: Int = 0 {
        didSet { selectSegmentAtIndex(selectedSegmentIndex) }
    }

    override var enabled: Bool {
        didSet { segments.forEach { $0.enabled = enabled } }
    }

    private func subscribe(segments: [UIButton]) {
        segments.forEach {
            $0.addTarget(self, action: action, forControlEvents: .TouchDown)
        }
    }

    private dynamic func selectSegment(sender: UIButton) {
        if let index = segments.indexOf(sender) where index != selectedSegmentIndex {
            selectedSegmentIndex = index
            sendActionsForControlEvents(.ValueChanged)
        }
    }

    private func selectSegmentAtIndex(index: Int) {
        segments.forEach { $0.selected = false }
        if index != UISegmentedControlNoSegment {
            segments[index].selected = true
        }
    }
}