import UIKit
import SwiftSocket

class ViewController: UIViewController {
    
    //消息输入框
    @IBOutlet weak var textFiled: UITextField!
    //消息输出列表
    @IBOutlet weak var textView: UITextView!
    
    //socket服务端封装类对象
    var socketServer:MyTcpSocketServer?
    //socket客户端类对象
    var socketClient:TCPClient?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        //启动服务器
        socketServer = MyTcpSocketServer()
        socketServer?.start()
        
        //初始化客户端，并连接服务器
        processClientSocket()
    }
    
    //初始化客户端，并连接服务器
    func processClientSocket(){
        socketClient=TCPClient(address: "localhost", port: 8080)
        
        DispatchQueue.global(qos: .background).async {
            //用于读取并解析服务端发来的消息
            func readmsg()->[String:Any]?{
                //read 4 byte int as type
                if let data=self.socketClient!.read(4){
                    if data.count==4{
                        let ndata=NSData(bytes: data, length: data.count)
                        var len:Int32=0
                        ndata.getBytes(&len, length: data.count)
                        if let buff=self.socketClient!.read(Int(len)){
                            let msgd = Data(bytes: buff, count: buff.count)
                            if let msgi = try? JSONSerialization.jsonObject(with: msgd,
                                                        options: .mutableContainers) {
                                return msgi as? [String:Any]
                            }
                        }
                    }
                }
                return nil
            }
            
            //连接服务器
            switch self.socketClient!.connect(timeout: 5) {
            case .success:
                DispatchQueue.main.async {
                    self.alert(msg: "connect success", after: {
                    })
                }
                
                //发送用户名给服务器（这里使用随机生成的）
                let msgtosend=["cmd":"nickname","nickname":"游客\(Int(arc4random()%1000))"]
                self.sendMessage(msgtosend: msgtosend)
                
                //不断接收服务器发来的消息
                while true{
                    if let msg=readmsg(){
                        DispatchQueue.main.async {
                            self.processMessage(msg: msg)
                        }
                    }else{
                        DispatchQueue.main.async {
                            //self.disconnect()
                        }
                        //break
                    }
                }
            case .failure(let error):
                DispatchQueue.main.async {
                    self.alert(msg: error.localizedDescription,after: {
                    })
                }
            }
        }
    }
    
    //“发送消息”按钮点击
    @IBAction func sendMsg(_ sender: AnyObject) {
        let content=textFiled.text!
        let message=["cmd":"msg","content":content]
        self.sendMessage(msgtosend: message)
        textFiled.text=nil
    }
    
    //发送消息
    func sendMessage(msgtosend:[String:String]){
        let msgdata=try? JSONSerialization.data(withJSONObject: msgtosend,
                                                options: .prettyPrinted)
        var len:Int32=Int32(msgdata!.count)
        let data = Data(bytes: &len, count: 4)
        _ = self.socketClient!.send(data: data)
        _ = self.socketClient!.send(data:msgdata!)
    }
    
    //处理服务器返回的消息
    func processMessage(msg:[String:Any]){
        let cmd:String=msg["cmd"] as! String
        switch(cmd){
        case "msg":
            self.textView.text = self.textView.text +
                (msg["from"] as! String) + ": " + (msg["content"] as! String) + "\n"
        default:
            print(msg)
        }
    }
    
    //弹出消息框
    func alert(msg:String,after:()->(Void)){
        let alertController = UIAlertController(title: "",
                                                message: msg,
                                                preferredStyle: .alert)
        self.present(alertController, animated: true, completion: nil)
        
        //1.5秒后自动消失
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1.5) {
            alertController.dismiss(animated: false, completion: nil)
        }
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}

import UIKit
import SwiftSocket

//服务器端口
var serverport:Int32 = 8080

//客户端管理类（便于服务端管理所有连接的客户端）
class ChatUser:NSObject{
    var tcpClient:TCPClient?
    var username:String=""
    var socketServer:MyTcpSocketServer?
    
    //解析收到的消息
    func readMsg()->[String:Any]?{
        //read 4 byte int as type
        if let data=self.tcpClient!.read(4){
            if data.count==4{
                let ndata = NSData(bytes: data, length: data.count)
                var len:Int32=0
                ndata.getBytes(&len, length: data.count)
                if let buff=self.tcpClient!.read(Int(len)){
                    let msgd = Data(bytes: buff, count: buff.count)
                    let msgi = (try! JSONSerialization.jsonObject(with: msgd,
                                options: .mutableContainers)) as! [String:Any]
                    return msgi
                }
            }
        }
        return nil
    }
    
    //循环接收消息
    func messageloop(){
        while true{
            if let msg=self.readMsg(){
                self.processMsg(msg: msg)
            }else{
                self.removeme()
                break
            }
        }
    }
    
    //处理收到的消息
    func processMsg(msg:[String:Any]){
        if msg["cmd"] as! String=="nickname"{
            self.username=msg["nickname"] as! String
        }
        self.socketServer!.processUserMsg(user: self, msg: msg)
    }
    
    //发送消息
    func sendMsg(msg:[String:Any]){
        let jsondata=try? JSONSerialization.data(withJSONObject: msg,
                                                 options:.prettyPrinted)
        var len:Int32=Int32(jsondata!.count)
        
        let data = Data(bytes: &len, count: 4)
        _ = self.tcpClient!.send(data: data)
        _ = self.tcpClient!.send(data: jsondata!)
    }
    
    //移除该客户端
    func removeme(){
        self.socketServer!.removeUser(u: self)
    }
    
    //关闭连接
    func kill(){
        _ = self.tcpClient!.close()
    }
}

//服务端类
class MyTcpSocketServer: NSObject {
    var clients:[ChatUser]=[]
    var server:TCPServer=TCPServer(address: "127.0.0.1", port: serverport)
    var serverRuning:Bool=false
    
    //启动服务
    func start() {
        _ = server.listen()
        self.serverRuning=true
        
        DispatchQueue.global(qos: .background).async {
            while self.serverRuning{
                let client=self.server.accept()
                if let c=client{
                    DispatchQueue.global(qos: .background).async {
                        self.handleClient(c: c)
                    }
                }
            }
        }
        
        self.log(msg: "server started...")
    }
    
    //停止服务
    func stop() {
        self.serverRuning=false
        _ = self.server.close()
        //forth close all client socket
        for c:ChatUser in self.clients{
            c.kill()
        }
        self.log(msg: "server stoped...")
    }
    
    //处理连接的客户端
    func handleClient(c:TCPClient){
        self.log(msg: "new client from:"+c.address)
        let u=ChatUser()
        u.tcpClient=c
        clients.append(u)
        u.socketServer=self
        u.messageloop()
    }
    
    //处理各消息命令
    func processUserMsg(user:ChatUser, msg:[String:Any]){
        self.log(msg: "\(user.username)[\(user.tcpClient!.address)]cmd:"+(msg["cmd"] as! String))
        //boardcast message
        var msgtosend=[String:String]()
        let cmd = msg["cmd"] as! String
        if cmd=="nickname"{
            msgtosend["cmd"]="join"
            msgtosend["nickname"]=user.username
            msgtosend["addr"]=user.tcpClient!.address
        }else if(cmd=="msg"){
            msgtosend["cmd"]="msg"
            msgtosend["from"]=user.username
            msgtosend["content"]=(msg["content"] as! String)
        }else if(cmd=="leave"){
            msgtosend["cmd"]="leave"
            msgtosend["nickname"]=user.username
            msgtosend["addr"]=user.tcpClient!.address
        }
        for user:ChatUser in self.clients{
            //if u~=user{
            user.sendMsg(msg: msgtosend)
            //}
        }
    }
    
    //移除用户
    func removeUser(u:ChatUser){
        self.log(msg: "remove user\(u.tcpClient!.address)")
        if let possibleIndex=self.clients.index(of: u){
            self.clients.remove(at: possibleIndex)
            self.processUserMsg(user: u, msg: ["cmd":"leave"])
        }
    }
    
    //日志打印
    func log(msg:String){
        print(msg)
    }
}