package service
  
  import (
  	"fmt"
  	"github.com/golang/protobuf/proto"
  	"pro2d/cmd/test/action"
  	"pro2d/common"
  	"pro2d/common/components"
  	"pro2d/common/logger"
  	"pro2d/models"
  	"pro2d/pb"
  	"sync/atomic"
  )
  
  type TestClient struct {
  	components.IConnector
  
  	Token              string
  	RoleTest           *models.RoleTestModel
  	lastHeartCheckTime int64
  }
  
  func NewTestClient() *TestClient {
  	options := []components.ConnectorOption{
  		components.WithCtorCount(common.GlobalConf.TestClient.Count),
  		components.WithCtorSplitter(components.NewPBSplitter(nil)),
  	}
  
  	client := components.NewConnector(common.GlobalConf.TestClient.Ip, common.GlobalConf.TestClient.Port, options...)
  	if err := client.Connect(); err != nil {
  		logger.Error(err)
  		return nil
  	}
  	t := &TestClient{IConnector: client}
  
  	client.GetConn().SetConnectionCallback(t.OnConn)
  	client.GetConn().SetMessageCallback(t.OnMessage)
  	client.GetConn().SetCloseCallback(t.OnClose)
  	client.GetConn().SetTimerCallback(t.OnTimer)
  	client.GetConn().Start()
  	return t
  }
  
  func (t *TestClient) OnConn(conn components.IConnection) {
  }
  
  func (t *TestClient) OnLoginQuery(msg components.IMessage) {
  	errCode := msg.GetHeader().GetErrCode()
  	if errCode != 0 {
  		logger.Error("Login errcode: %d", errCode)
  
  		if errCode == 2 {

  			req := &pb.CreateRar{

  				Token:  t.Token,
  				Device: "test-create",
  			}
  			r, _ := proto.Marshal(req)

  			t.GetConn().SendSuccess(uint32(pb.ProtoCode_CreateRpc), r, 0)

  			return
  		}
  	}
  

  	req := pb.LoginRsp{}

  	if err := proto.Unmarshal(msg.GetData(), &req); err != nil {
  		logger.Error("loginRpc err: %v", err)
  		return
  	}
  
  	t.RoleTest = models.NewRoleTestModel(req)
  }
  
  func (t *TestClient) OnMessage(msg components.IMessage) {
  	atomic.StoreInt64(&t.lastHeartCheckTime, common.Timex())
  	logger.Debug("rsp errCode:%d, protocolID: %d", msg.GetHeader().GetErrCode(), msg.GetHeader().GetMsgID())
  
  	//login rsp

  	if msg.GetHeader().GetMsgID() == uint32(pb.ProtoCode_LoginRpc) {

  		t.OnLoginQuery(msg)
  		return
  	}
  
  	errCode := msg.GetHeader().GetErrCode()
  	if errCode != 0 {
  		logger.Error("protocolID: %d, errCode %d", msg.GetHeader().GetMsgID(), errCode)
  		return
  	}
  
  	//get handler by msgid
  	md, ok := action.GetTestActionMap()[msg.GetHeader().GetMsgID()]
  	if !ok {
  		fmt.Errorf("cmd: %d, handler is nil", msg.GetHeader().GetMsgID())
  		return
  	}
  
  	//调用协议号对应的逻辑函数
  	f := md.(func(role *models.RoleTestModel, msg components.IMessage))
  	f(t.RoleTest, msg)
  }
  
  func (t *TestClient) OnClose(conn components.IConnection) {

  	conn.Stop()

  }
  func (t *TestClient) OnTimer(conn components.IConnection) {
  }
  
  func (t *TestClient) Login(token string) {
  	t.Token = token
  	head := &components.PBHead{
  		Length:   0,

  		Cmd:      uint32(2),

  		ErrCode:  0,
  		PreField: 0,
  	}
  	loginReq := &pb.LoginReq{
  		Token:  token,
  		Device: "test-login",
  	}
  	l, _ := proto.Marshal(loginReq)

  	t.Send(head.Cmd, l, 0)

  }