import 'dart:async';
import 'dart:io';
import 'dart:typed_data';
 
import 'package:protobuf/protobuf.dart';
import 'package:gobang/network/protobuf/Gobang.pb.dart';
import 'package:gobang/game/global.dart';
 
 
/** 消息长度用2个字节描述 */
const int msgByteLen = 2;
 
/** 消息号用2个字节描述 */
const int msgCodeByteLen = 2;
 
/** 最小的消息长度为4个字节（即消息长度+消息号） */
const int minMsgByteLen = msgByteLen + msgCodeByteLen;
 
 
/**
 * 网络管理器类
 */
class NetworkManager{
 
  /** 服务器ip */
  final String host;
 
  /** 服务器端口 */
  final int port;
 
  Socket socket;
 
  /** 缓存的网络数据，暂未处理（一般这里有数据，说明当前接收的数据不是一个完整的消息，需要等待其它数据的到来拼凑成一个完整的消息） */
  Int8List cacheData = Int8List(0);
 
  NetworkManager(this.host, this.port);
 
  /**
   * 初始化连接服务器
   */
  void init() async{
    try {
      socket = await Socket.connect(host, port, timeout: Duration(seconds: 2));
    } catch (e) {
      print("连接socket出现异常，e=${e.toString()}");
    }
    socket.listen(decodeHandle,
        onError: errorHandler,
        onDone: doneHandler,
        cancelOnError: false);
  }
 
  /**
   * 解码处理方法
   * 处理服务器发过来的数据，注意，这里要处理粘包，这个data参数不一定是一个完整的包
   */
  void decodeHandle(newData){
    //拼凑当前最新未处理的网络数据
    cacheData = Int8List.fromList(cacheData + newData);
 
    //缓存数据长度符合最小包长度才尝试解码
    while(cacheData.length >= minMsgByteLen){
        //读取消息长度
        var byteData = cacheData.buffer.asByteData();
        var msgLen = byteData.getInt16(0);
 
        //数据长度小于消息长度，说明不是完整的数据，暂不处理
        if(cacheData.length < msgLen + msgByteLen){
          return;
        }
 
        //读取消息号
        int msgCode = byteData.getInt16(msgCodeByteLen);
 
        //读取pb数据
        int pbLen = msgLen - msgCodeByteLen;
        Int8List pbBody;
        if(pbLen > 0){
          pbBody = cacheData.sublist(minMsgByteLen, msgLen + msgByteLen);
        }
 
        //整理缓存数据
        int totalLen = msgByteLen + msgLen;
        cacheData = cacheData.sublist(totalLen, cacheData.length);
 
        Function handler = msgHandlerPool[msgCode];
        if(handler == null){
          print("没有找到消息号$msgCode的处理器");
          return;
        }
 
        //处理消息
        handler(pbBody);
    }
  }
 
  /**
   * 发消息，指定消息号，pb对象可以为不传(例如发心跳包的时候)
   */
  void sendMsg(int msgCode, [GeneratedMessage pb]){
    //序列化pb对象
    Uint8List pbBody;
    int pbLen = 0;
    if(pb != null) {
      pbBody = pb.writeToBuffer();
      pbLen = pbBody.length;
    }
 
    //包头部分
    var header = ByteData(minMsgByteLen);
    header.setInt16(0, msgCodeByteLen + pbLen);
    header.setInt16(msgByteLen, msgCode);
 
    //包头+pb组合成一个完整的数据包
    var msg = pbBody == null ? header.buffer.asUint8List() : header.buffer.asUint8List() + pbBody.buffer.asUint8List();
 
    //给服务器发消息
    try {
      socket.add(msg);
      print("给服务端发送消息，消息号=$msgCode");
    } catch (e) {
      print("send捕获异常：msgCode=${msgCode}，e=${e.toString()}");
    }
  }
 
  void errorHandler(error, StackTrace trace){
    print("捕获socket异常信息：error=$error，trace=${trace.toString()}");
    socket.close();
  }
 
  void doneHandler(){
    socket.destroy();
    print("socket关闭处理");
  }
 
}
 
/**
 * 测试
 */
main() async {
  //创建网络管理器
  var networkManager = NetworkManager("127.0.0.1", 8060);
  await networkManager.init();
 
  //创建登陆的pb对象并赋值
  LoginReq req = LoginReq.create();
  req.uniqueId = "123";
 
  //发送登陆请求
  networkManager.sendMsg(100, req);
 
  //每秒发一次心跳请求
  Timer.periodic(Duration(seconds: 1), (t){
    netManager.sendMsg(101);
    lastSendHeartTime = new DateTime.now().millisecondsSinceEpoch;
  });
}