package timelimitactivityrank

// import (
// 	"encoding/json"
// 	"fmt"
// 	"leafstalk/covenant/model"
// 	"leafstalk/covenant/msg"
// 	"leafstalk/covenant/servers"
// 	"leafstalk/log"
// 	"leafstalk/otherutils/redisdo"
// 	"net/url"
// 	"store/db"
// 	"store/mailbox"
// 	"strconv"
// 	"time"

// 	"github.com/gomodule/redigo/redis"
// )

// const (
// 	defaultTimeScore = 1000_0000
// )

// type TimeLimitRank struct {
// 	Name            string // 活动名称
// 	TimeScoreMask   int64  // = 1000_0000
// 	MailType        int
// 	FindRankAward   func(int) ([]*model.DropMaterial, []int64)
// 	GetActivityTime func() (startTime int64, endTime int64)

// 	RankItemList  []*msg.NormalRankItem
// 	FastQueryRank map[int64]*msg.NormalRankItem
// }

// func (t *TimeLimitRank) RankKey(startTime int64) string {
// 	period := time.Unix(startTime, 0).Format("20060102")
// 	return fmt.Sprintf("%vrank:%v", t.Name, period)
// }

// func (t *TimeLimitRank) RankRewardKey() string {
// 	return fmt.Sprintf("%vrank_award", t.Name) //"lady38rank_award"
// }

// // 结算上一期活动排行
// // startTime：上期活动的开始时间
// // count: 上期活动排行奖励人数
// func (t *TimeLimitRank) SettleRankReward(startTime int64, count int) {

// 	//获取成员数，建立发奖项目，定时发送一定数量，发送完毕后，删除
// 	key := t.RankKey(startTime)
// 	cnt, err := redis.Int(redisdo.Do("ZCARD", key))
// 	if err != nil {
// 		log.WithField("from", t.Name).Errorln("SettleRankPrize ZCARD error: ", key, err)
// 		return
// 	}

// 	awardKey := t.RankRewardKey()
// 	_, err = redisdo.Do("HMSET", awardKey, "total", cnt, "start", 0, "stop", 0, "key", key)
// 	if err != nil {
// 		log.WithField("from", t.Name).Errorln("SettleRankPrize HMSET error: ", key, err)
// 		return
// 	}
// }

// // 获取周期排行信息
// func (t *TimeLimitRank) getRankList(key string, start int, stop int) (list []*model.NormalRankItem) {

// 	datas, err := redis.Int64s(redisdo.Do("ZREVRANGE", key, start, stop, "WITHSCORES"))
// 	if err != nil {
// 		log.WithField("from", t.Name).Errorf("getRankList key %s fail, err: %s", key, err.Error())
// 		return
// 	}

// 	//其他人排名
// 	l1 := len(datas)
// 	index := 0
// 	for i := 0; i < l1; i += 2 {
// 		playerId := datas[i]
// 		score := datas[i+1] / t.TimeScoreMask
// 		index += 1

// 		rk := new(model.NormalRankItem)
// 		rk.PlayerID = playerId
// 		rk.Level = int(score)
// 		rk.Rank = index + start
// 		list = append(list, rk)
// 	}

// 	return list
// }

// // 定时发送一部分排行奖励邮件
// func (t *TimeLimitRank) SendRankPrizeByTimer() {
// 	//获取当前已发送信息
// 	awardKey := t.RankRewardKey()
// 	datas, err := redis.StringMap(redisdo.Do("HGETALL", awardKey))
// 	if err != nil {
// 		log.WithField("from", t.Name).Errorln("SendRankPrizeByTimer HGETALL error: ", err)
// 		return
// 	}
// 	if len(datas) == 0 {
// 		return
// 	}
// 	total, _ := strconv.Atoi(datas["total"])
// 	start, _ := strconv.Atoi(datas["start"])
// 	stop, _ := strconv.Atoi(datas["stop"])
// 	rankKey := datas["key"]

// 	expTime := time.Now().Add(time.Hour * 24 * 7)
// 	if stop < total {
// 		// 设置新的发奖范围
// 		start = stop
// 		if start > 0 {
// 			start += 1
// 		}
// 		stop = start + 300 //100
// 		if stop > total {
// 			stop = total
// 		}
// 		_, err = redisdo.Do("HMSET", awardKey, "start", start, "stop", stop)
// 		if err != nil {
// 			log.WithField("from", t.Name).Errorf("SendRankPrizeByTimer %v HMSET error. week: %v, start - end: %v %v, error: %v", awardKey, start, stop, err)
// 			return
// 		}

// 		//获奖
// 		// 获取周排行信息
// 		list := t.getRankList(rankKey, start, stop)
// 		if list == nil {
// 			log.WithField("from", t.Name).Errorf("SendRankPrizeByTimer getRankList error. key: %v, start - end: %v %v, error: %v", rankKey, start, stop, err)
// 			return
// 		}

// 		// 批量插入
// 		var letterLst []*model.Letter
// 		for _, item := range list {
// 			ms, es := t.FindRankAward(item.Rank)
// 			if ms != nil || es != nil {
// 				letter := new(model.Letter)
// 				letter.PlayerId = item.PlayerID
// 				letter.Type = t.MailType
// 				letter.Extra.Materials = ms
// 				letter.Extra.Equips = es
// 				letter.ExpireTime = expTime
// 				extra := model.LetterExtraInfo{
// 					Level: item.Level,
// 					Rank:  item.Rank,
// 				}
// 				jex, err := json.Marshal(&extra)
// 				if err != nil {
// 					log.WithField("from", t.Name).Errorf("SendRankPrizeByTimer LetterExtraRank marshal error. %v, error: %v", extra, err)
// 					continue
// 				}
// 				letter.ExtraInfo = string(jex)
// 				letterLst = append(letterLst, letter)
// 			} else { // 如果奖品为空，说明后续无奖励了，直接跳出
// 				break
// 			}
// 		}

// 		if len(letterLst) == 0 {
// 			return
// 		}

// 		// 插入奖品
// 		_, err := db.GetEngine().Insert(&letterLst)
// 		if err != nil {
// 			log.WithField("from", t.Name).Errorf("SendRankPrizeByTimer Insert error. key: %v, start - end: %v %v, error: %v", rankKey, start, stop, err)
// 			return
// 		}
// 		mailbox.AddNewLetters(letterLst)

// 		//广播
// 		mm := new(msg.MsgMulticast)
// 		mm.Type = 1
// 		for _, v := range letterLst {
// 			mm.PlayerIds = append(mm.PlayerIds, v.PlayerId)
// 		}
// 		servers.SendToPlayersByGates(-12, mm)
// 	}

// 	//删除发奖项目
// 	if stop >= total {
// 		_, err = redis.Int(redisdo.Do("DEL", awardKey))
// 		if err != nil {
// 			log.WithField("from", t.Name).Errorln("SendRankPrizeByTimer DEL error: ", err)
// 			return
// 		}
// 	}
// }

// func isActivityOpened(ct int64, st int64, et int64) bool {
// 	if st == 0 && et == 0 {
// 		return true
// 	}

// 	if ct >= st && ct <= et {
// 		return true
// 	}
// 	return false
// }

// // refreshRankingList 刷新内存中的rankingList
// func (t *TimeLimitRank) refreshRankingList() ([]*msg.NormalRankItem, map[int64]*msg.NormalRankItem) {
// 	// 现在需要刷新排行吗？
// 	ct := time.Now().Unix()
// 	st, et := t.GetActivityTime()
// 	if !isActivityOpened(ct, st, et) {
// 		return nil, nil
// 	}

// 	key := t.RankKey(st)
// 	datas, err := redis.Int64s(redisdo.Do("ZREVRANGE", key, 0, 500, "WITHSCORES"))
// 	if err != nil {
// 		log.WithField("from", t.Name).Errorf("refreshRankingList get %s fail, err: %s", key, err.Error())
// 		return nil, nil
// 	}

// 	//其他人排名
// 	var list []*msg.NormalRankItem
// 	fast := make(map[int64]*msg.NormalRankItem)
// 	l1 := len(datas)
// 	index := 0
// 	for i := 0; i < l1; i += 2 {
// 		playerId := datas[i]
// 		score := datas[i+1] / t.TimeScoreMask
// 		index += 1

// 		rk := new(msg.NormalRankItem)
// 		rk.PlayerID = playerId
// 		rk.Score = score
// 		rk.Rank = index

// 		list = append(list, rk)
// 		fast[rk.PlayerID] = rk
// 	}

// 	//加载昵称
// 	var ids []int64
// 	for _, v := range list {
// 		ids = append(ids, v.PlayerID)

// 		// if v2, ok := t.FastQueryRank[v.PlayerID]; ok {
// 		// 	v.NickName = v2.NickName
// 		// 	v.CombatEffe = v2.CombatEffe
// 		// 	// v.HeadImg = v2.HeadImg
// 		// } else {
// 		// 	ids = append(ids, v.PlayerID)
// 		// }
// 	}

// 	if len(ids) > 0 {
// 		players := db.LoadNameCombat(ids)
// 		for _, v := range players {
// 			if v2, ok := fast[v.PlayerId]; ok {
// 				v2.NickName = url.QueryEscape(v.NickName)
// 				v2.CombatEffe = v.CombatEffe
// 				v2.HeadImg = v.ImgUrl
// 				v2.FrameId = v.HeadImg.FrameId
// 				v2.HeadId = v.HeadImg.HeadId
// 			}
// 		}
// 	}

// 	return list, fast
// }

// func (t *TimeLimitRank) getTimeScore(startTime int64, endTime int64) int64 {
// 	max := endTime - startTime
// 	if max >= t.TimeScoreMask {
// 		max = t.TimeScoreMask - 1
// 	}

// 	ct := time.Now().Unix()
// 	score := endTime - ct
// 	if score > max {
// 		return max
// 	} else if score < 0 {
// 		return 0
// 	}
// 	return int64(score)
// }

// // 更新排行 score:总积分
// func (t *TimeLimitRank) updatePlayerRank(playerId int64, score int64) {

// 	var args []interface{}

// 	//key
// 	st, et := t.GetActivityTime()
// 	key := t.RankKey(st)
// 	args = append(args, key)

// 	// score
// 	timeScore := t.getTimeScore(st, et)

// 	nscore := score*t.TimeScoreMask + timeScore
// 	args = append(args, nscore, playerId)

// 	//保存
// 	_, err := redisdo.Do("zadd", args...)
// 	if err != nil {
// 		log.WithField("from", t.Name).Warnf("updateRedisScore error %v", err)
// 	}
// }