declare namespace TopSinSocket {
    export class TcpSocketImpl {
        /**
         * 中止连接
         */
        abort():void

        /**
         * 绑定地址和端口，返回是否成功
         */
        bind(ip:String, port:Number):boolean

        /**
         * 连接到主机
         */
        connectToHost(ip:String, port:Number):void

        /**
         * 断开与主机的连接，如果还有数据在写，那么会在结束后断开
         */
        disconnectFromHost();

        /**
         * 返回最近的一次错误
         */
        error():String

        /**
         * 冲刷缓存
         */
        flush():boolean

        /**
         * socket是否可用
         */
        isValid():boolean

        /**
         * 本地ip
         */
        localAddress():String

        /**
         * 本地port
         */
        localPort():Number

        /**
         * 对端ip
         */
        peerAddress():String

        /**
         * 对端port
         */
        peerPort():Number

        /**
         * 读缓存大小
         */
        readBufferSize():Number
        
        /**
         * 设置读缓存大小
         */
        setReadBufferSize(size:Number):void

        /**
         * 等待直到连接成功或超时
         * 
         * @param msec 超时时间（毫秒）
         * @return true 表示连接成功，false表示超时
         */
        waitForConnected(msec:Number):boolean

        /**
         * 等待直到断开连接
         * 
         * @param msec 超时时间（毫秒）
         * @return true 表示断开成功，false表示超时
         */
        waitForDisconnected(msec:Number):boolean

        /**
         * 等待直到发送完至少1字节或超时
         * 
         * @param msec 超时时间（毫秒）
         * @return true 表示已发送至少1字节， false表示超时
         */
        waitForReadyRead(msec:Number):boolean

        /**
         * 是否已读完
         */
        atEnd():boolean

        /**
         * 可读字节数
         */
        bytesAvailable():Number

        /**
         * 待写字节数
         */
        bytesToWrite():Number

        /**
         * 是否可读一行数据
         * 注意：二进制数据不一定存在换行
         */
        canReadLine():boolean

        /**
         * 关闭连接
         */
        close():void

        /**
         * 错误消息
         */
        errorString():String

        /**
         * 连接是否打开
         */
        isOpen():boolean

        /**
         * 是否可读
         */
        isReadable():boolean

        /**
         * 是否可写
         */
        isWritable():boolean

        /**
         * 读取数据
         * 如果数据不够会发生阻塞
         * 
         * @param size 数据大小
         * @return 返回size大小的数据
         */
        read(size:Number):String

        /**
         * 读取全部数据直到不可读
         * 
         * @return 读到的数据
         */
        readAll():String

        /**
         * 读取一行数据
         * 注意：二进制数据不一定存在换行
         */
        readLine():String

        /**
         * 发送数据
         * 
         * @param data 字符串（准确的说是 node 中的Buffer)
         * @return 发送完成的字节数
         */
        write(data:String):Number

        /**
         *  注册事件
         * 
         * connected
         * 连接成功，对应的callback： function（conn: TcpSocket) {}
         * 
         * disconnected
         * 连接断开，对应的callback: function(conn: TcpSocket) {}
         * 
         * error
         * 发生错误， 对应的callback： function（conn: TcpSocket, error:String) {}
         * 
         * byteswritten
         * 发送完数据， 对应的callback： function(conn: TcpSocket, nbytes: Number) {}
         * 
         * readready
         * 连接可读， 对应的callback： function(conn: TcpSocket) {}
         */
        on(event:TcpSocketEvent, callback:Function)
    }
    

    export class TcpServerImpl {
        constructor(parent:mainLoop):void

        /**
         * 关闭连接
         */
        close():void
    
        /**
         * 最后一个错误原因
         */
        errorString():String
    
        /**
         * 是否有排队连接
         */
        hasPendingConnections():boolean
    
        /**
         * 监听地址、端口
         */
        listten(addr:String, port:Number):boolean
    
        /*** accepterror
     * accept出错，对应的callback: function(err: string) {}
         * 是否在监听
         */
        isListening():boolean
    
        /**
         * 最大排队连接数
         */
        maxPendingConnections():Number
    
        /**
         * 下一个排队连接
         */
        nextPendingConnection():TcpSocket
    
        /**
         * 暂停接受新的连接
         */
        pauseAccepting():void
    
        /**
         * 恢复接受新的连接
         */
        resumeAcception():void
    
        /**
         * 服务端监听地址
         */
        serverAddress():String
    
        /**
         * 服务端监听端口
         */
        serverPort():Number
    
        /**
         * 服务端错误
         */
        serverError():String
    
        /**
         * 设置最大排队连接
         */
        setMaxPendingConnections(n:Number):void
    
        /**
         * 等待下一个连接
         * 
         * @param msec 等待的毫秒数
         * @return 是否成功
         */
        waitForNewConnection(msec:Number):boolean
    
        /**
         * 注册事件
         * 
         * accepterror
         * accept出错，对应的callback: function(server: TcpServer, err: string) {}
         * 
         * newconnection
         * 新的客户端连接成功，对应的callback: function(conn: TcpSocket) {}
         */
        on(event:TcpServerEvent, callback:Function):void
    }

    /**
    * 创建一个新的TcpServer对象
    * 
    * @param parent 全局的事件循环
    * @example
    * 
    * var socket = require('topsin.socket');
    * var server = socket.TcpServer(mainLoop);
    * 
    * server.on('newconnection', function(conn) {
    *      console.log("client: " + conn.peerPort() + ", connected");
    *      conn.on('readready', function(conn) {
    *          var data = conn.readAll();
    *          console.log(data);
    *          conn.write(data);
    *      });
    *      conn.on("disconnected", function(c) {
    *          console.log("client: " + c.peerPort() + ", closed");
    *      });
    * );
    * 
    * server.on('accepterror', function(server) {
    *      server.close();
    *      console.log("exit");
    *      mainLoop.quit();
    * });
    * 
    * server.listen("127.0.0.1", 8888);
    * mainLoop.exec();
    */
    export function TcpServer(parent:mainLoop):TcpServerImpl;

    /**
     * 创建一个新的TcpSocket对象
     * 
     * @param parent 全局的事件循环
     * 
     * @example
     *  
     * var socket = require('topsin.socket');
     * 
     * var client = socket.TcpSocket(mainLoop);
     * client.on('connected', function(conn) {
     *       console.log("connected");
     * });
     *  
     * conn.on('readready', function(conn) {
     *       var data = conn.readAll();
     *       console.log(data);
     *       conn.write(data);
     *  });
     *  
     *  conn.on('disconnected', function(conn) {
     *       console.log(conn.errorString());
     *       mainLoop.quit();     
     *  });
     *  
     *  client.connectToHost("127.0.0.1", 8888);
     *  mainLoop.exec();
     */
    export function TcpSocket(parent:mainLoop):TcpSocketImpl;
}

export class mainLoop {};
export = TopSinSocket;