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 LvApiResp struct {
	Code int32          `json:"code"`
	Msg  string         `json:"msg"`
	Data *LvApiRespData `json:"data"`
}
type LvApiRespData struct {
	List []string `json:"list"` // 用户绑定的标签
}

type LvApi struct {
	S2S

	log *model.LvAPILog
}

func NewLvApi(ctx context.Context, conf *model.FissionConfig, opts ...Option) (*LvApi, error) {
	r := &LvApi{}

	err := r.init(ctx, conf.ProjectID, conf.LvURLID, opts...)
	if err != nil {
		return nil, err
	}

	return r, nil
}

func (s *LvApi) LvApi(cpn *model.FissionCampaign, userId, langMark, source string) (res *LvApiRespData, err error) {
	var resp, errMsg string
	var code int32
	defer func() {
		s.after(code, resp, errMsg)
	}()

	m := s.GetDao().FissionUserLevel
	var marks = make([]string, 0)
	err = m.WithContext(s.Ctx).Where(m.ProjectID.Eq(cpn.ProjectID), m.DeletedAt.Eq(0)).Pluck(m.Mark, &marks)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	req := mtype.LvApiLogReq{
		UserId:            userId,
		CampaignId:        cpn.HashID,
		Title:             cpn.Title,
		State:             "get_user_type",
		TlSettingUserType: marks,
	}

	s.before(cpn.ID, userId, source, req)

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

	var data = &LvApiResp{}
	err = jsonm.StrUnmarshal(resp, data)
	if err != 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 *LvApi) before(cpnId int64, userId, source string, req mtype.LvApiLogReq) {
	s.log = withdefault.LvApiLog(&model.LvAPILog{
		CampaignID: cpnId,
		UserID:     userId,
		Source:     source,
		ReqURL:     s.GetUrl(),
	})

	s.log.SetReq(req)

	_ = s.GetDao().LvAPILog.WithContext(s.Ctx).Create(s.log)
	s.start = time.Now()
}

func (s *LvApi) 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().LvAPILog.WithContext(s.Ctx).Save(s.log)
}