/**
 * 创建时间 2017/04/16
 */
module PomeloLaya{

    export class Pomelo{

        static DEBUG:boolean = true;
        static EVENT_IO_ERROR:string = "io-error";
        static EVENT_CLOSE:string = "close";
        static EVENT_KICK:string = "onKick";
        static EVENT_HEART_BEAT_TIMEOUT:string = 'heartbeat timeout';

        private JS_WS_CLIENT_TYPE:string = 'js-websocket';
        private JS_WS_CLIENT_VERSION:string = '0.0.5';

        private RES_OK:number = 200;
        private RES_FAIL:number = 500;
        private RES_OLD_CLIENT:number = 501;


        private socket:Laya.Socket = null;
        private callbacks:any = {};
        private handlers:any = {};
        // Map from request id to route
        private routeMap = {};

        private heartbeatInterval:number = 0;
        private heartbeatTimeout:number = 0;
        private nextHeartbeatTimeout:number = 0;
        private gapThreshold:number = 100;
        private heartbeatId:any = null;
        private heartbeatTimeoutId:any = null;

        private handshakeCallback:any = null;
        private handshakeBuffer:any;
        private initCallback:Function = null;

        private _callbacks:any = {};

        private reqId:number = 0;


        private _package:IPackage;
        private _message:IMessage;

        constructor(){
            if(!console.group){
                console.group = console.log;
                console.groupEnd = function(){console.log("----")};
                console.info = console.log;
                console.warn = console.log;
                console.error = console.log;
            }

            this._message = new Message();
            this._package = new Package();

            this.socket = null;
            this.callbacks = {};
            this.handlers = {};
            // Map from request id to route
            this.routeMap = {};

            this.heartbeatInterval = 0;
            this.heartbeatTimeout = 0;
            this.nextHeartbeatTimeout = 0;
            this.gapThreshold = 100;
            this.heartbeatId = null;
            this.heartbeatTimeoutId = null;

            this.handshakeCallback = null;

            this.handshakeBuffer = {
                'sys': {
                    type: this.JS_WS_CLIENT_TYPE,
                    version: this.JS_WS_CLIENT_VERSION
                },
                'user': {
                }
            };

            this.initCallback = null;

            this.reqId = 0;

            this.handlers[Package.TYPE_HANDSHAKE] = this.handshake;
            this.handlers[Package.TYPE_HEARTBEAT] = this.heartbeat;
            this.handlers[Package.TYPE_DATA] = this.onData;
            this.handlers[Package.TYPE_KICK] = this.onKick;
        }


        public init(params,cb:Function):void{
            console.log("init",params);
            this.initCallback = cb;
            var host = params.host;
            var port = params.port;
            var uid = params.session_id;
            var user_name = params.user_name;
            //
            //var url = 'ws://' + host;
            //if(port) {
            //    url +=  ':' + port;
            //}

            this.handshakeBuffer.user = params.user;
            this.handshakeCallback = params.handshakeCallback;
            this.initWebSocket(host,port, cb);
        }
        private initWebSocket(host,port,cb:Function):void{
            console.log("[Pomelo] connect to:",host,port);

            this.socket = new Laya.Socket();
            //用的子协议，字符串或数组
            // this.socket.protocols = egret.WebSocket.TYPE_BINARY;

            this.socket.on(Laya.Event.OPEN, this, this.onConnect);
            this.socket.on(Laya.Event.CLOSE, this, this.onClose);
            this.socket.on(Laya.Event.ERROR, this, this.onIOError);
            this.socket.on(Laya.Event.MESSAGE, this, this.onMessage);
            this.socket.connect(host,port);
        }


        public on(event, fn){
            (this._callbacks[event] = this._callbacks[event] || []).push(fn);
        }
        public request(route, msg, cb) {
            if(arguments.length === 2 && typeof msg === 'function') {
                cb = msg;
                msg = {};
            } else {
                msg = msg || {};
            }
            route = route || msg.route;
            if(!route) {
                return;
            }

            this.reqId++;
            if(this.reqId>127){
                this.reqId = 1;
            }
            var reqId = this.reqId;
                console.log("request"+msg);

            if(Pomelo.DEBUG){
                console.group("REQUEST:");
                console.info("Route:",route);
                console.log("Id:",reqId);
                console.log("Param:",msg);
                console.groupEnd();
            }

            this.sendMessage(reqId, route, msg);

            this.callbacks[reqId] = cb;
            this.routeMap[reqId] = route;
        }
        
        public notify(route:string, msg:any):void {
            this.sendMessage(0, route, msg);
        }

        private onMessage(event:Laya.Event):void{
            console.log("onMessage"+event);
            // var byte:Laya.Byte = new Laya.Byte();
            // this.socket.input.readBytes(byte);
            if (event instanceof ArrayBuffer){
                var byte:Laya.Byte = new Laya.Byte(event);
                this.socket.input.clear();
                this.processPackage(this._package.decode(byte));
            }

        }
        private sendMessage(reqId, route, msg) {
            var byte:Laya.Byte;

            // var msgbuffer = Protocol.strencode(JSON.stringify(msg));
            // console.log("msgbuffer",msgbuffer);
            var msgbuffer = this._message.encode(reqId, route, msg);
            byte = this._package.encode(Package.TYPE_DATA, msgbuffer);
            this.send(byte); 
        }

        private onConnect(e:Laya.Event):void {
            console.log("[Pomelo] connect success",e);
            var handshakejson = JSON.stringify(this.handshakeBuffer);
            console.log("handshakejson :",handshakejson);
            var handshakebuffer = Protocol.strencode(handshakejson);
            var buffer = this._package.encode(Package.TYPE_HANDSHAKE,handshakebuffer);
            
            // this.socket.send('{"cmd":0,"data":{"user_name":"test0001","password":"abcd1234"}}@');
            this.send(buffer);
            this.socket.output.writeArrayBuffer(buffer);
            this.socket.flush();
        }

        private onClose(e:Laya.Event):void {
            console.error("[Pomelo] connect close:",e);
            this.emit(Pomelo.EVENT_CLOSE,e);
        }

        private onIOError(e:Laya.Event):void{
            this.emit(Pomelo.EVENT_IO_ERROR, e);
            console.error('socket error: ', e);
        }

        private onKick(event){
            this.emit(Pomelo.EVENT_KICK,event);
        }
        private onData(data){
            //probuff decode
            var msg = this._message.decode(data);
            console.log("onData msg:",msg);
            if(msg.id > 0){
                msg.route = this.routeMap[msg.id];
                delete this.routeMap[msg.id];
                if(!msg.route){
                    return;
                }
            }

            //msg.body = this.deCompose(msg);

            this.processMessage(msg);

        }

        private processMessage(msg) {
            if(!msg.id) {
                // server push message

                if(Pomelo.DEBUG){
                    console.group("EVENT:");
                    console.info("Route:",msg.route);
                    console.info("Msg:",msg.body);
                    console.groupEnd();
                }

                this.emit(msg.route, msg.body);
                return;
            }
            if(Pomelo.DEBUG){
                console.group("RESPONSE:");
                console.info("Id:",msg.id);
                console.info("Msg:",msg.body);
                console.groupEnd();
            }

            //if have a id then find the callback function with the request
            var cb = this.callbacks[msg.id];

            delete this.callbacks[msg.id];
            if(typeof cb !== 'function') {
                return;
            }
            if(msg.body && msg.body.code == 500){
                var obj:any = {"code":500,"desc":"服务器内部错误","key":"INTERNAL_ERROR"};
                msg.body.error = obj;
            }
            cb(msg.body);
            return;
        }

        private heartbeat(data){

            if(!this.heartbeatInterval) {
                // no heartbeat
                return;
            }

            var obj = this._package.encode(Package.TYPE_HEARTBEAT);
            if(this.heartbeatTimeoutId) {
                Laya.timer.clear(this,this.heartbeatTimeoutId);
                this.heartbeatTimeoutId = null;
            }

            if(this.heartbeatId) {
                // already in a heartbeat interval
                return;
            }

            var self = this;
            self.heartbeatId = Laya.timer.once(self.heartbeatInterval,self,
            function() {
                self.heartbeatId = null;
                self.send(obj);

                self.nextHeartbeatTimeout = Date.now() + self.heartbeatTimeout;
                self.heartbeatTimeoutId = self.heartbeatTimeoutCb.bind(self,data);
                Laya.timer.once( self.heartbeatTimeout,self,self.heartbeatTimeoutCb.bind(self,data));
            })
        }
        private heartbeatTimeoutCb(data) {
            var gap = this.nextHeartbeatTimeout - Date.now();
            if(gap > this.gapThreshold) {
                this.heartbeatTimeoutId = Laya.timer.once(gap,this,this.heartbeatTimeoutCb,);
            } else {
                console.error('server heartbeat timeout',data);
                this.emit(Pomelo.EVENT_HEART_BEAT_TIMEOUT,data);
                this._disconnect();
            }
        }
        public off(event?,fn?){
            this.removeAllListeners(event,fn);
        }
        public removeAllListeners(event?, fn?){
            // all
            if (0 == arguments.length) {
                this._callbacks = {};
                return;
            }

            // specific event
            var callbacks = this._callbacks[event];
            if (!callbacks){
                return;
            }

            // remove all handlers
            if (event && !fn) {
                delete this._callbacks[event];
                return;
            }

            // remove specific handler
            var i = this.index(callbacks, fn._off || fn);
            if (~i){
                callbacks.splice(i, 1);
            }
            return;
        }
        private index(arr, obj){
            if ([].indexOf){
                return arr.indexOf(obj);
            }

            for (var i = 0; i < arr.length; ++i) {
                if (arr[i] === obj)
                    return i;
            }
            return -1;
        }
        public disconnect():void{
            this._disconnect();
        }
        private _disconnect():void {
            console.warn("[Pomelo] client disconnect ...");

            if (this.socket && this.socket.connected) this.socket.close();
            this.socket = null;
            if(this.heartbeatId){
                // Laya.timer.clear(this.heartbeatId);
                this.heartbeatId = null;
            }

            if(this.heartbeatTimeoutId) {
                // Laya.timer.clear(this.heartbeatTimeoutId);
                this.heartbeatTimeoutId = null;
            }

        }
        private processPackage(msg):void{
            this.handlers[msg.type].apply(this,[msg.body]);
        }
        private handshake(resData){
            var resStr = Protocol.strdecode(resData);
            // console.log("resStr:",resStr);//握手
            var data = JSON.parse(resStr);
            if(data.code === this.RES_OLD_CLIENT) {
                this.emit(Pomelo.EVENT_IO_ERROR, 'client version not fullfill');
                return;
            }

            if(data.code !== this.RES_OK) {
                this.emit(Pomelo.EVENT_IO_ERROR, 'handshake fail');
                return;
            }

            this.handshakeInit(data);

            var obj = this._package.encode(Package.TYPE_HANDSHAKE_ACK);
            this.send(obj);
            if(this.initCallback) {
                this.initCallback(data);
                this.initCallback = null;
            }
        }
        private handshakeInit(data):void{

            if(data.sys){
                Routedic.init(data.sys.dict);
                Protobuf.init(data.sys.protos);
            }
            if(data.sys && data.sys.heartbeat) {
                this.heartbeatInterval = data.sys.heartbeat * 1000;   // heartbeat interval
                this.heartbeatTimeout = this.heartbeatInterval * 2;        // max heartbeat timeout
            } else {
                this.heartbeatInterval = 0;
                this.heartbeatTimeout = 0;
            }

            if(typeof this.handshakeCallback === 'function') {
                this.handshakeCallback(data.user);
            }
        }
        private send(byte:Laya.Byte):void{
           
            if (this.socket && this.socket.connected)
            {   
                // var byteArray:ArrayBuffer = new ArrayBuffer(byte.length);
                // byte.pos = 0;
                // var bytestr = "length:"+byte.length+"["
                // for(var i = 0 ; i < byte.length;i++){
                //     var rbyte  = byte.readByte();
                //     this.socket.output.writeByte(rbyte);
                //     if(i == byte.length - 1){
                //         bytestr += rbyte+"";
                //     }else{
                //         bytestr += rbyte+",";
                //     }
                // }
                // bytestr += "]@";
                // console.log("send :"+bytestr);
                var bytestr='{"cmd":0,"data":{"user_name":"test0001","password":"abcd1234"}}@';
                 console.log(bytestr);
                this.socket.flush();
            }
        }
        //private deCompose(msg){
        //    return JSON.parse(Protocol.strdecode(msg.body));
        //}
        private emit(event, ...args:any[]){
            var params = [].slice.call(arguments, 1);
            var callbacks = this._callbacks[event];

            if (callbacks) {
                callbacks = callbacks.slice(0);
                for (var i = 0, len = callbacks.length; i < len; ++i) {
                    callbacks[i].apply(this, params);
                }
            }

            return this;
        }
        /**
         * 
         * 写入Laya.Byte
         * @param(Laya.Byte) 需要写入的Laya.Byte
         * @param(Laya.Byte) 写入的Laya.Byte
         * 
         */
        public static writeBytes(fromByte:Laya.Byte,toByte:Laya.Byte){
            fromByte.pos = 0;
            for(var i = 0 ; i < fromByte.length;i++){
                var rbyte = fromByte.getByte();
                toByte.writeByte(rbyte);
            }
        }
        /**
         * 打印Laya.Byte
         */
        public static logByte(byte:Laya.Byte){
            byte.pos = 0;
            var bytestr = "length:"+byte.length+"\r\n["
            for(var i = 0 ; i < byte.length;i++){
                var rbyte = byte.getByte();
                if(i == byte.length-1){
                    bytestr += rbyte+"";
                }else{
                    bytestr += rbyte+",";
                }
            }
            bytestr += "]";
            console.log(bytestr);
        }
    }

    class Package implements IPackage{
        static TYPE_HANDSHAKE:number = 1;
        static TYPE_HANDSHAKE_ACK:number = 2;
        static TYPE_HEARTBEAT:number = 3;
        static TYPE_DATA:number = 4;
        static TYPE_KICK:number = 5;

        public encode(type:number,body?:Laya.Byte) :Laya.Byte{
            var length:number = body ? body.length : 0;

            var buffer:Laya.Byte = new Laya.Byte();
            buffer.writeByte(type & 0xff);
            buffer.writeByte((length >> 16) & 0xff);
            buffer.writeByte((length >> 8) & 0xff);
            buffer.writeByte(length & 0xff);

            // if(body) buffer.writeArrayBuffer(body, 0, body.length);
            if(body) {
                Pomelo.writeBytes(body,buffer);
            }
            return buffer;
        }
        public decode(buffer:Laya.Byte){

            var type:number = buffer.getUint8();
            var len:number = (buffer.getUint8() << 16 | buffer.getUint8() << 8 | buffer.getUint8()) >>> 0;

            var body:Laya.Byte;

            if (buffer.bytesAvailable >= len)
            {
                // body = new Laya.Byte();
                // if (len) buffer.writeArrayBuffer(body, 0, len);
                if(len){
                    body = new Laya.Byte(buffer.getUint8Array(buffer.pos,buffer.bytesAvailable));
                }
            }
            else
            {
                console.log("[Package] no enough length for current type:", type);
            }

            return {type:type, body:body, length:len};
        }
    }

    class Message implements IMessage{

        public static MSG_FLAG_BYTES:number = 1;
        public static MSG_ROUTE_CODE_BYTES:number = 2;
        public static MSG_ID_MAX_BYTES:number = 5;
        public static MSG_ROUTE_LEN_BYTES:number = 1;

        public static MSG_ROUTE_CODE_MAX:number = 0xffff;

        public static MSG_COMPRESS_ROUTE_MASK:number = 0x1;
        public static MSG_TYPE_MASK:number = 0x7;

        static TYPE_REQUEST:number = 0;
        static TYPE_NOTIFY:number = 1;
        static TYPE_RESPONSE:number = 2;
        static TYPE_PUSH:number = 3;

        public encode(id:number, route:string, msg:any){
            var buffer:Laya.Byte = new Laya.Byte();

            var type:number = id ? Message.TYPE_REQUEST : Message.TYPE_NOTIFY;

            var byte:Laya.Byte = Protobuf.encode(route, msg) || Protocol.strencode(JSON.stringify(msg));

            var rot:any = Routedic.getID(route) || route;

            //add flag 
            buffer.writeByte((type << 1) | ((typeof(rot)=="string") ? 0 : 1));

            if (id)
            {
                // 7.x
                do
                {
                    var tmp:number = id % 128;
                    var next:number = Math.floor(id / 128);

                    if (next != 0)
                    {
                        tmp = tmp + 128;
                    }

                    buffer.writeByte(tmp);

                    id = next;
                } while (id != 0);

                // 5.x
//				var len:Array = [];
//				len.push(id & 0x7f);
//				id >>= 7;
//				while(id > 0)
//				{
//					len.push(id & 0x7f | 0x80);
//					id >>= 7;
//				}
//
//				for (var i:int = len.length - 1; i >= 0; i--)
//				{
//					buffer.writeByte(len[i]);
//				}
            }

            if (rot)
            {
                if (typeof rot == "string")
                {
                    buffer.writeByte(rot.length & 0xff);
                    buffer.writeUTFBytes(rot);
                }
                else
                {
                    buffer.writeByte((rot >> 8) & 0xff);
                    buffer.writeByte(rot & 0xff);
                }
            }

            if (byte)
            {               	
                Pomelo.writeBytes(byte,buffer);
            }
            return buffer;
        }

        public decode(buffer:Laya.Byte):any
        {
            // parse flag
            var flag:number = buffer.getUint8();
            var compressRoute:number = flag & Message.MSG_COMPRESS_ROUTE_MASK;
            var type:number = (flag >> 1) & Message.MSG_TYPE_MASK;
            var route:any;

            // parse id
            var id:number = 0;
            if (type === Message.TYPE_REQUEST || type === Message.TYPE_RESPONSE)
            {
                // 7.x
                var i:number = 0;
                do
                {
                    var m:number = buffer.getUint8();
                    id = id + ((m & 0x7f) * Math.pow(2, (7 * i)));
                    i++;
                } while(m >= 128);

                // 5.x
//				var byte:int = buffer.readUnsignedByte();
//				id = byte & 0x7f;
//				while(byte & 0x80)
//				{
//					id <<= 7;
//					byte = buffer.readUnsignedByte();
//					id |= byte & 0x7f;
//				}
            }

            // parse route
            if (type === Message.TYPE_REQUEST || type === Message.TYPE_NOTIFY || type === Message.TYPE_PUSH)
            {

                if (compressRoute)
                {
                    route = buffer.getUint16();
                }
                else
                {
                    var routeLen:number = buffer.getUint8();
                    route = routeLen ? buffer.readUTFBytes(routeLen) : "";
                }
            }
            //else if (type === Message.TYPE_RESPONSE)
            //{
            //    route = Pomelo.requests[id].route;
            //}
            //
            if (!id && !(typeof(route) == "string"))
            {
                route = Routedic.getName(route);
            }
            if (route == undefined){
                route = '';
            }
            var bodyarray = Protobuf.decode(route, buffer);//此处后期需要完善
            var body:any 
            if(bodyarray){
                body = bodyarray;
            }else{

                var bodystr = Protocol.strdecode(new Laya.Byte(buffer.getUint8Array(buffer.pos,buffer.bytesAvailable)));
                var bodyjson:any = JSON.parse(bodystr);
                body = bodyjson
            }

            return {id:id, type:type, route:route, body:body};
        }
       encodeMsgFlag(type:number, compressRoute:number, buffer:Laya.Byte) {
            if (type !== Message.TYPE_REQUEST && type !== Message.TYPE_NOTIFY &&
                type !== Message.TYPE_RESPONSE && type !== Message.TYPE_PUSH) {
                throw new Error('unkonw message type: ' + type);
            }
            buffer.writeByte((type << 1) | (compressRoute ? 1 : 0));
        };
    }
    class Protocol{

        public static strencode(str:string):Laya.Byte {
            var buffer:Laya.Byte = new Laya.Byte();
            buffer.length = str.length;
            buffer.writeUTFBytes(str);
            return buffer;
            // var byteArray = new ArrayBuffer(str.length * 3);
            // var offset = 0;
            // for (var i = 0; i < str.length; i++) {
            //     var charCode = str.charCodeAt(i);
            //     var codes = null;
            //     if (charCode <= 0x7f) {
            //     codes = [charCode];
            //     } else if (charCode <= 0x7ff) {
            //     codes = [0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f)];
            //     } else {
            //     codes = [0xe0 | (charCode >> 12), 0x80 | ((charCode & 0xfc0) >> 6), 0x80 | (charCode & 0x3f)];
            //     }
            //     for (var j = 0; j < codes.length; j++) {
            //     byteArray[offset] = codes[j];
            //     ++offset;
            //     }
            // }
            // var _buffer = new ArrayBuffer(offset);
            // this.copyArray(_buffer, 0, byteArray, 0, offset);
            // var bytbuffer = new Laya.Byte(_buffer);
            // return bytbuffer;
        }

        public static strdecode(byte:Laya.Byte):string
        {
            // return byte.readUTFBytes(byte.bytesAvailable);
            // var bytes = new ByteArray(buffer);
            var array = [];
            var offset = 0;
            var charCode = 0;
            var end = byte.length;
            byte.pos = 0;
            while (offset < end) {
                var index = byte.getUint8();
                if (index < 128) {
                    charCode = index ;
                    offset += 1;
                } else if (index  < 224) {
                    charCode = ((index  & 0x3f) << 6) + (byte.getUint8()  & 0x3f);
                    offset += 2;
                } else {
                    charCode = ((index  & 0x0f) << 12) + ((byte.getUint8()  & 0x3f) << 6) + (byte.getUint8()  & 0x3f);
                    offset += 3;
                }
                array.push(charCode);
            }
            var res = '';
            var chunk = 8 * 1024;
            var i;
            for (i = 0; i < array.length / chunk; i++) {
                res += String.fromCharCode.apply(null, array.slice(i * chunk, (i + 1) * chunk));
            }
            res += String.fromCharCode.apply(null, array.slice(i * chunk));
            return res;
        }
        public static copyArray(dest, doffset, src, soffset, length) {
            if ('function' === typeof src.copy) {
                // Buffer
                src.copy(dest, doffset, soffset, soffset + length);
            } else {
                // Uint8Array
                for (var index = 0; index < length; index++) {
                dest[doffset++] = src[soffset++];
                }
            }
        };
    }
    class Protobuf{
        static TYPES:any = {
            uInt32 : 0,
            sInt32 : 0,
            int32 : 0,
            double : 1,
            string : 2,
            message : 2,
            float : 5
        };
        private static _clients:any = {};
        private static _servers:any = {};

        static init(protos:any):void{
            this._clients = protos && protos.client || {};
            this._servers = protos && protos.server || {};
        }

        static encode(route:string, msg:any):Laya.Byte{

            var protos:any = this._clients[route];

            if (!protos) return null;

            return this.encodeProtos(protos, msg);
        }

        static decode(route:string, buffer:Laya.Byte):any{

            var protos:any = this._servers[route];

            if (!protos) return null;

            return this.decodeProtos(protos, buffer);
        }
        private static encodeProtos(protos:any, msg:any):Laya.Byte {
            var buffer:Laya.Byte = new Laya.Byte();

            for (var name in msg)
            {
                if (protos[name])
                {
                    var proto:any = protos[name];

                    switch (proto.option)
                    {
                        case "optional":
                        case "required":
                            buffer.writeArrayBuffer(this.encodeTag(proto.type, proto.tag));
                            this.encodeProp(msg[name], proto.type, protos, buffer);
                            break;
                        case "repeated":
                            if (!!msg[name] && msg[name].length > 0)
                            {
                                this.encodeArray(msg[name], proto, protos, buffer);
                            }
                            break;
                    }
                }
            }

            return buffer;
        }
        static decodeProtos(protos:any, buffer:Laya.Byte):any {
            var msg:any = {};

            while(buffer.bytesAvailable)
            {
                var head:any = this.getHead(buffer);
                var name:string = protos.__tags[head.tag];

                switch (protos[name].option)
                {
                    case "optional":
                    case "required":
                        msg[name] = this.decodeProp(protos[name].type, protos, buffer);
                        break;
                    case "repeated":
                        if (!msg[name])
                        {
                            msg[name] = [];
                        }
                        this.decodeArray(msg[name], protos[name].type, protos, buffer);
                        break;
                }
            }

            return msg;
        }

        static encodeTag(type:number, tag:number):Laya.Byte {
            var value:number = this.TYPES[type]!=undefined ? this.TYPES[type] : 2;

            return this.encodeUInt32((tag << 3) | value);
        }
        static getHead(buffer:Laya.Byte):any {
            var tag:number = this.decodeUInt32(buffer);

            return { type: tag & 0x7, tag: tag >> 3 };
        }
        static encodeProp(value:any, type:string, protos:any, buffer:Laya.Byte):void {
            switch(type) {
                case 'uInt32':
                    // buffer.writeArrayBuffer(this.encodeUInt32(value));
                    Pomelo.writeBytes(this.encodeUInt32(value),buffer);
                    break;
                case 'int32':
                case 'sInt32':
                    // buffer.writeArrayBuffer(this.encodeSInt32(value));
                    Pomelo.writeBytes(this.encodeSInt32(value),buffer);
                    break;
                case 'float':
                    //Float32Array
                    // var floats:Laya.Byte = new Laya.Byte();
                    // floats.endian = Laya.Byte.LITTLE_ENDIAN;
                    // floats.getFloat32(value);
                    // buffer.writeArrayBuffer(floats);
                    Pomelo.writeBytes(this.encodeFloat(value),buffer);
                    break;
                case 'double':
                    // var doubles:Laya.Byte = new Laya.Byte();
                    // doubles.endian = Laya.Byte.LITTLE_ENDIAN;
                    // doubles.getFloat32(value);
                    // buffer.writeArrayBuffer(doubles);
                    Pomelo.writeBytes(this.encodeDouble(value),buffer);
                    break;
                case 'string':
                    // buffer.writeArrayBuffer(this.encodeUInt32(value.length));
                    Pomelo.writeBytes(this.encodeUInt32(value.length),buffer);
                    buffer.writeUTFBytes(value);
                    break;
                default:
                    var proto:any = protos.__messages[type] || this._clients["message " + type];
                    if (!!proto)
                    {
                        var buf:Laya.Byte = this.encodeProtos(proto, value);
                        // buffer.writeArrayBuffer(this.encodeUInt32(buf.length));
                        Pomelo.writeBytes(this.encodeUInt32(value.length),buffer);
                        buffer.writeArrayBuffer(buf);
                    }
                    break;
            }
        }

        static decodeProp(type:string, protos:any, buffer:Laya.Byte):any {
            switch(type) {
                case 'uInt32':
                    return this.decodeUInt32(buffer);
                case 'int32':
                case 'sInt32':
                    return this.decodeSInt32(buffer);
                case 'float':
                    var floats:Laya.Byte = new Laya.Byte();
                    // buffer.writeArrayBuffer(floats, 0, 4);
                    var uint8arry = buffer.getUint8Array(0,4);
                    for(var i = 0 ; i < uint8arry.length;i++){
                         floats.writeByte(uint8arry[i]);
                    }                    
                    floats.endian = Laya.Byte.LITTLE_ENDIAN;
                    var float:number = buffer.getFloat32();
                    return floats.getFloat32();
                case 'double':
                    var doubles:Laya.Byte = new Laya.Byte();
                    // buffer.writeArrayBuffer(doubles, 0, 8);
                    var uint8arry = buffer.getUint8Array(0,8);
                    for(var i = 0 ; i < uint8arry.length;i++){
                         doubles.writeByte(uint8arry[i]);
                    }   
                    doubles.endian = Laya.Byte.LITTLE_ENDIAN;
                    return doubles.getFloat64();
                case 'string':
                    var length:number = this.decodeUInt32(buffer);
                    return buffer.readUTFBytes(length);
                default:
                    var proto:any = protos && (protos.__messages[type] || this._servers["message " + type]);
                    if(proto)
                    {
                        var len:number = this.decodeUInt32(buffer);

                        if (len)
                        {
                            var buf:Laya.Byte = new Laya.Byte();
                            // buffer.writeArrayBuffer(buf, 0, len);
                            var uint8arry = buffer.getUint8Array(0,len);
                            for(var i = 0 ; i < uint8arry.length;i++){
                                buf.writeByte(uint8arry[i]);
                            }   
                        }

                        return len ? Protobuf.decodeProtos(proto, buf) : false;
                    }
                    break;
            }
        }

        static isSimpleType(type:string):boolean {
            return (
            type === 'uInt32' ||
            type === 'sInt32' ||
            type === 'int32'  ||
            type === 'uInt64' ||
            type === 'sInt64' ||
            type === 'float'  ||
            type === 'double'
            );
        }
        static encodeArray(array:Array<any>, proto:any, protos:any, buffer:Laya.Byte):void {
            var isSimpleType = this.isSimpleType;
            if(isSimpleType(proto.type)) {
                // buffer.writeArrayBuffer(this.encodeTag(proto.type, proto.tag));
                // buffer.writeArrayBuffer(this.encodeUInt32(array.length));
                Pomelo.writeBytes(this.encodeTag(proto.type, proto.tag),buffer);
                Pomelo.writeBytes(this.encodeUInt32(array.length),buffer);
                var encodeProp = this.encodeProp;
                for (var i:number = 0; i < array.length; i++) {
                    encodeProp(array[i], proto.type, protos, buffer);
                }
            } else {
                var encodeTag = this.encodeTag;
                for (var j:number = 0; j < array.length; j++) {
                    // buffer.writeArrayBuffer(encodeTag(proto.type, proto.tag));
                    Pomelo.writeBytes(this.encodeTag(proto.type, proto.tag),buffer);
                    this.encodeProp(array[j], proto.type, protos, buffer);
                }
            }
        }
        static decodeArray(array:Array<any>, type:string, protos:any, buffer:Laya.Byte):void {
            var isSimpleType = this.isSimpleType;
            var decodeProp = this.decodeProp;

            if(isSimpleType(type)) {
                var length:number = this.decodeUInt32(buffer);
                for(var i:number = 0; i < length; i++) {
                    array.push(decodeProp(type, protos, buffer));
                }
            } else {
                array.push(decodeProp(type, protos, buffer));
            }
        }

        static encodeUInt32(n:number):Laya.Byte {
            var result:Laya.Byte = new Laya.Byte();

            do {
                var tmp:number = n % 128;
                var next:number = Math.floor(n / 128);

                if(next !== 0){
                    tmp = tmp + 128;
                }

                result.writeByte(tmp);
                n = next;
            }
            while(n !== 0);

            return result;
        }
        static decodeUInt32(buffer:Laya.Byte):number {
            var n:number = 0;

            for (var i:number = 0; i < buffer.length; i++)
            {
                var m:number = buffer.getUint8();
                n = n + ((m & 0x7f) * Math.pow(2,(7*i)));
                if (m < 128)
                {
                    return n;
                }
            }
            return n;
        }
        static encodeSInt32(n:number):Laya.Byte {
            n = n < 0 ? (Math.abs(n) * 2 - 1) : n * 2;

            return this.encodeUInt32(n);
        }
        static decodeSInt32(buffer:Laya.Byte):number {
            var n:number = this.decodeUInt32(buffer);

            var flag:number = ((n % 2) === 1) ? -1 : 1;

            n = ((n % 2 + n) / 2) * flag;

            return n;
        }
        static encodeFloat(value:number):Laya.Byte  {
            var floats:Laya.Byte = new Laya.Byte;
            floats.endian = Laya.Byte.LITTLE_ENDIAN;
            floats.writeFloat32(value);
            return floats
        };
        static encodeDouble(value:number):Laya.Byte  {
            var floats:Laya.Byte = new Laya.Byte;
            floats.endian = Laya.Byte.LITTLE_ENDIAN;
            floats.writeFloat64(value);
            return floats
        };

    }
    class Routedic{
        private static _ids:Object = {};
        private static _names:Object = {};

        static init(dict:any):void {
            this._names = dict || {};
            var _names = this._names;
            var _ids = this._ids;
            for (var name in _names)
            {
                _ids[_names[name]] = name;
            }
        }

        static getID(name:string){
            return this._names[name];
        }
        static getName(id:number){
            return this._ids[id];
        }
    }

    interface IMessage{
        /**
         * encode
         * @param id
         * @param route
         * @param msg
         * @return ByteArray
         */
        encode(id:number, route:string, msg:any):Laya.Byte;

        /**
         * decode
         * @param buffer
         * @return Object
         */
        decode(buffer:Laya.Byte):any;
    }
    interface IPackage{

        encode(type:number, body?:Laya.Byte):Laya.Byte

        decode(buffer:Laya.Byte):any
    }


}