package nft

import (
	"context"
	"errors"
	"github.com/shopspring/decimal"
	"github.com/spf13/cast"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"nova_task/internal/consts"
	"nova_task/internal/model"
	"nova_task/internal/pkg/utils"
	"nova_task/internal/svc"
	"time"
)

type StakeSettleLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewStakeSettleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StakeSettleLogic {
	return &StakeSettleLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *StakeSettleLogic) StakeSettle(date string) {
	l.Infow("start stake settle", logx.Field("date", date))
	tt, err := time.ParseInLocation(time.DateOnly, date, time.Local)
	if err != nil {
		l.Errorw("parse date failed", logx.Field("err", err), logx.Field("date", date))
		return
	}
	start, end, err := l.svcCtx.ConfigModel.GetNftStakeTaskOpenDate(l.ctx)
	if err != nil {
		l.Errorw("get nft stake task open date failed", logx.Field("err", err))
		return
	}
	//start = start.AddDate(0, 0, 1)
	//end = end.AddDate(0, 0, 1)
	if tt.Before(start) || tt.After(end) {
		l.Infow("now is not in the date range", logx.Field("now", tt), logx.Field("start", start), logx.Field("end", end))
		return
	}

	taskConf, err := l.svcCtx.ConfigModel.GetNftStakeTaskConf(l.ctx)
	if err != nil {
		l.Errorw("get nft stake task conf failed", logx.Field("err", err))
		return
	}

	stakes, err := l.svcCtx.StakeNftModel.AllStakeNft(l.ctx)
	if err != nil {
		l.Errorw("get all stake nft failed", logx.Field("err", err))
		return
	}

	uid2tokens := map[uint]float64{}
	for _, s := range stakes {
		if s.State != 1 {
			continue
		}
		nftHolder, err := l.svcCtx.NftHolderModel.FindOneByTokenId(l.ctx, s.TokenId)
		if err != nil {
			l.Errorw("find nft holder failed", logx.Field("err", err), logx.Field("tokenId", s.TokenId))
			continue
		}

		uid, err := l.svcCtx.WalletModel.FindUidByAddress(l.ctx, nftHolder.Address)
		if err != nil {
			l.Errorw("find uid by address failed", logx.Field("err", err), logx.Field("address", nftHolder.Address))
			continue
		}

		if uid != s.Uid {
			l.Errorw("uid not match", logx.Field("uid", s.Uid), logx.Field("nftHolderUid", uid))
			continue
		}

		if utils.IsBigTarot(s.TokenId) {
			uid2tokens[s.Uid] += float64(taskConf.GreatTarot)
		} else {
			uid2tokens[s.Uid] += float64(taskConf.LittleTarot)
		}
	}

	// 二测质押未提取的用户
	oldStakeNfts, err := l.svcCtx.OldStakeNftModel.AllStakeNft(l.ctx)
	if err != nil {
		l.Errorw("get all old stake nft failed", logx.Field("err", err))
	} else {
		for _, s := range oldStakeNfts {
			if utils.IsBigTarot(cast.ToString(s.TokenId)) {
				uid2tokens[s.UserId] += float64(taskConf.GreatTarot)
			} else {
				uid2tokens[s.UserId] += float64(taskConf.LittleTarot)
			}
		}
	}

	awardSeq := cast.ToInt(tt.Format("20060102"))
	for uid, tokens := range uid2tokens {
		coefficient, err := l.svcCtx.StakeRewardModel.GetRandomCoefficientByUid(l.ctx, uid, awardSeq, taskConf.MinCoefficient, taskConf.MaxCoefficient)
		if err != nil {
			l.Errorw("get random coefficient failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq))
			continue
		}
		tokensDecimal := decimal.NewFromFloat(tokens)
		reward := tokensDecimal.Mul(decimal.NewFromFloat(coefficient))
		var gameBonus int
		if l.svcCtx.GamePitModel.UserExist(l.ctx, uid) {
			gameBonus = taskConf.OccupyPercent
			reward = reward.Mul(decimal.NewFromFloat(float64(100+gameBonus) / 100))
		}
		err = l.svcCtx.DBConn.TransactCtx(l.ctx, func(ctx context.Context, session sqlx.Session) error {
			err = l.svcCtx.StakeRewardModel.SetReward(l.ctx, uid, awardSeq, gameBonus, tokensDecimal, reward)
			if err != nil {
				//logx.Errorw("set reward failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("coefficient", coefficient), logx.Field("tokens", tokens), logx.Field("reward", reward))
				return err
			}

			// 加资产
			err = l.svcCtx.AddUserAssetWithSession(l.ctx, session, uid, 0, consts.AssetType_Castile, "", reward, "nft软质押奖励", 0, 0, false)
			return err
		})

		if err != nil {
			if errors.Is(err, model.ErrNoRowUpdate) {
				l.Infow("质押结算已发放奖励，无需重复发放", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("coefficient", coefficient), logx.Field("tokens", tokens), logx.Field("reward", reward))
			} else {
				l.Errorw("质押结算发放奖励失败", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("coefficient", coefficient), logx.Field("tokens", tokens), logx.Field("reward", reward))
			}
		} else {
			l.Infow("质押结算发放奖励成功", logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("coefficient", coefficient), logx.Field("tokens", tokens), logx.Field("reward", reward))
		}
	}
}