package s2s

import (
	"context"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"
)

type UserInfoResp struct {
	Code int32             `json:"code"`
	Msg  string            `json:"msg"`
	Data *UserInfoRespData `json:"data"`
}
type UserInfoRespData struct {
	CoinNum int64 `json:"coin_num"`
}

type UserInfo struct {
	S2S

	user *model.ProjectUser
	log  *model.ProjectUserInfoLog
}

func NewUserInfo(ctx context.Context, user *model.ProjectUser, urlId int64, opts ...Option) (*UserInfo, error) {
	c := &UserInfo{
		user: user,
	}

	err := c.init(ctx, user.ProjectID, urlId, opts...)
	if err != nil {
		return nil, err
	}

	return c, nil
}

// UserInfo 获取用户信息
func (s *UserInfo) UserInfo(langMark string) (res *UserInfoRespData, err error) {
	var resp, errMsg string
	var code int32
	defer func() {
		s.after(code, resp, errMsg)
	}()

	req := mtype.ProjectUserInfoReq{
		UserId: s.user.UserID,
	}

	s.before(req)

	body, _ := jsonm.Marshal(req)
	resp, code, err = s.request(s.log.ID, body, langMark, prefixBearer, NewCertToken)
	if err != nil {
		errMsg = fmt.Sprintf("请求处理失败: %v", err)
		err = workerr.S2SNotSuccessError
		return
	}

	var data = &UserInfoResp{}
	err = jsonm.StrUnmarshal(resp, data)
	if err != nil || data.Data == nil {
		errMsg = fmt.Sprintf("无法解析的返回数据: %v", err)
		err = workerr.S2SUnableToParseError
		return
	}

	if data.Code != successCode {
		errMsg = "code返回的非200，请确认业务是否正确对接"
		if data.Msg != "" {
			errMsg = fmt.Sprintf("code返回的非200, 提供的信息为: %s", data.Msg)
		}
		err = workerr.S2SNotSuccessError
		return
	}

	res = data.Data

	return
}

func (s *UserInfo) before(req mtype.ProjectUserInfoReq) {
	s.log = withdefault.ProjectUserInfoLog(&model.ProjectUserInfoLog{
		ProjectID: s.user.ProjectID,
		UserID:    s.user.ID,
		ReqURL:    s.GetUrl(),
	})

	s.log.SetReq(req)
	_ = s.GetDao().ProjectUserInfoLog.WithContext(s.Ctx).Create(s.log)

	s.start = time.Now()
}

func (s *UserInfo) after(code int32, resp, errMsg string) {
	s.log.RespCode = code
	s.log.Resp = resp
	s.log.ErrMsg = errMsg
	s.log.Token = s.GetToken()
	s.log.ReqHeader = s.GetHeader()
	s.log.ReqTime = time.Since(s.start).Milliseconds()

	_ = s.GetDao().ProjectUserInfoLog.WithContext(s.Ctx).Save(s.log)
}