package s2s

import (
	"context"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"fmt"
	"time"

	"joybuywork/proto/go_proto/workerr"
)

const (
	PointsChangeSuccess = "success" // 处理成功
	PointsChangeLack    = "lack"    // 余额不足扣除失败
)

type PointsChangeResp struct {
	Code int32                 `json:"code"`
	Msg  string                `json:"msg"`
	Data *PointsChangeRespData `json:"data"`
}
type PointsChangeRespData struct {
	State    string `json:"state"`     // 状态（success - 成功，lack - 缺乏）
	RelateId string `json:"relate_id"` // 成功关联的唯一信息
}

type PointsChange struct {
	S2S

	user *model.FissionUser
	cpn  *model.FissionCampaign
	log  *model.FissionPointsLog
}

func NewPointsChange(ctx context.Context, cpn *model.FissionCampaign, user *model.FissionUser, urlId int64, opts ...Option) (*PointsChange, error) {
	c := &PointsChange{
		user: user,
		cpn:  cpn,
	}

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

	return c, nil
}

func (s *PointsChange) Deduct(num int32, source string, other mtype.PointsLogOther) (res *PointsChangeRespData, err error) {
	return s.Change(num, mtype.FissionPointsLogStateDeduct, source, other)
}

func (s *PointsChange) CoinGain(player *model.FissionCoin, num int32) (res *PointsChangeRespData, err error) {
	return s.Change(num, mtype.FissionPointsLogStateGain, mtype.FissionPointsLogSourceCoin, mtype.PointsLogOther{
		PlayerId: player.ID,
		SceneId:  player.SceneID,
	})
}

func (s *PointsChange) CoinDeduct(player *model.FissionCoin, num int32, deductId int64) (res *PointsChangeRespData, err error) {
	return s.Change(num, mtype.FissionPointsLogStateDeduct, mtype.FissionPointsLogSourceCoin, mtype.PointsLogOther{
		PlayerId: player.ID,
		SceneId:  player.SceneID,
		DeductId: deductId,
	})
}

// Change 积分变更
func (s *PointsChange) Change(num int32, state, source string, other mtype.PointsLogOther) (res *PointsChangeRespData, err error) {
	var resp, errMsg string
	var code int32
	defer func() {
		s.after(code, resp, errMsg)
	}()

	req := mtype.PointsLogReq{
		State:      state,
		Num:        num,
		UserId:     s.user.SubUserID,
		Source:     source,
		CampaignId: s.cpn.HashID,
		Title:      s.cpn.Title,
	}

	switch state {
	case mtype.FissionPointsLogStateGain:
		req.GainId = fmt.Sprint(other.PlayerId)
	case mtype.FissionPointsLogStateDeduct:
		req.DeductId = fmt.Sprint(other.DeductId)
	}

	s.before(source, req, other)

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

	var data = &PointsChangeResp{}
	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 *PointsChange) before(source string, req mtype.PointsLogReq, other mtype.PointsLogOther) {
	s.log = withdefault.FissionPointsLog(&model.FissionPointsLog{
		CampaignID: s.user.CampaignID,
		UserID:     s.user.ID,
		State:      req.State,
		Num:        req.Num,
		Source:     source,
		ReqURL:     s.GetUrl(),
	})

	s.log.SetReq(req)
	s.log.SetOtherData(other)
	_ = s.GetDao().FissionPointsLog.WithContext(s.Ctx).Create(s.log)

	s.start = time.Now()
}

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