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)
}