Swift websockets

swift-ws

import UIKit

class ViewController: UIViewController {
    let wSock = wSocket(key: "afa4d38348f89ba9c398")
    
    override func viewDidLoad() {
        super.viewDidLoad()        
        
        var ch = wSock.subscribe("test-channel")
        ch.bind("test-event", { (data: JSON) -> Void in
            if let test = data["test"].stringValue {
                println(test)
            }
        })
        println(ch.callbacks)
    }
}

class wSocketClient {
    let connection: Connection
    
    init(key: String, encrypted: Bool = false) {
        var url = "SOCKET_URL"
        connection = Connection(url: url)
    }
    
    func subscribe(channelName: String) -> Channel {
        return self.connection.addChannel(channelName)
    }
    
    func connect() {
        self.connection.open()
    }
}

class Connection: WebSocketDelegate {
    let url: String
    lazy var socket: WebSocket = { [unowned self] in
        return self.connectInternal()
    }()
    let connected = false
    var channels = Channels()
    
    init(url: String) {
        self.url = url
    }
    
    func addChannel(channelName: String) -> Channel {
        return Channel(name: channelName)
    }
    
    func JSONStringify(value: AnyObject) -> String {
        if NSJSONSerialization.isValidJSONObject(value) {
            if let data = NSJSONSerialization.dataWithJSONObject(value, options: nil, error: nil) {
                if let string = NSString(data: data, encoding: NSUTF8StringEncoding) {
                    return string
                }
            }
        }
        return ""
    }
    
    func close() {
        if self.connected {
            self.socket.disconnect()
        }
    }
    
    func open() {
        if self.connected {
            return
        } else {
            self.socket = connectInternal()
        }
    }
    
    func connectInternal() -> WebSocket {
        let ws = WebSocket(url: NSURL(string: self.url)!)
        ws.delegate = self
        ws.connect()
        return ws
    }
    
    func websocketDidReceiveMessage(text: String) {
        let data = (text as NSString).dataUsingEncoding(NSUTF8StringEncoding)
        let json = JSON(data: data!)
        
        if let channelName = json["channel"].stringValue {
            if let internalChannel = self.channels.find(channelName) {
                if let eName = json["event"].stringValue {
                    if let eData = json["data"].stringValue {
                        internalChannel.handleEvent(eName, eventData: eData)
                    }
                }
            }
        }
    }
}

class Channel {    
    var callbacks: [String: (JSON) -> Void]
    var subscribed = false
    let name: String
    
    init(name: String) {
        self.name = name
        self.callbacks = [:]
    }
    
    func bind(eventName: String, callback: (JSON) -> Void) {
        self.callbacks[eventName] = callback
    }
    
    func handleEvent(eventName: String, eventData: String) {
        if let cb = self.callbacks[eventName] {
            let json = JSON(object: eventData)
            cb(json)
        }
    }
}

class Channels {
    var channels = [String: Channel]()
    
    func add(channelName: String) -> Channel {
        if let channel = self.channels[channelName] {
            return channel
        } else {
            let newChannel = Channel(name: channelName)
            self.channels[channelName] = newChannel
            return newChannel
        }
    }
    
    func find(channelName: String) -> Channel? {
        return self.channels[channelName]
    }
}