egg_app/app/hdl/hdl_home_page.go

package hdl

import (
	"applet/app/db"
	"applet/app/e"
	"applet/app/md"
	"applet/app/svc"
	"applet/app/utils"
	"applet/app/utils/cache"
	"code.fnuoos.com/EggPlanet/egg_models.git/src/implement"
	"code.fnuoos.com/EggPlanet/egg_models.git/src/model"
	md2 "code.fnuoos.com/EggPlanet/egg_system_rules.git/rule/egg_energy/md"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/shopspring/decimal"
	"time"
)

// HomePage
// @Summary      蛋蛋星球-主页-基础信息(获取)
// @Tags         主页
// @Description  基础信息(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.HomePageResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/index [get]
func HomePage(c *gin.Context) {
	now := time.Now()
	val, exists := c.Get("user")
	if !exists {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}
	user, ok := val.(*model.User)
	if !ok {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}

	//1、查找 `egg_energy_basic_setting` 基础设置
	eggEnergyBasicSettingDb := implement.NewEggEnergyBasicSettingDb(db.Db)
	eggEnergyBasicSetting, err := eggEnergyBasicSettingDb.EggEnergyBasicSettingGetOneByParams(map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	//2、计算今日涨幅
	err, rises, isRise, nowPrice, initialPrice := svc.CalcTodayEggEnergyPriceRises(db.Db, now)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	//3、获取当前用户 蛋蛋能量(可用+结算+今日签到预估蛋蛋能量)
	var isSign bool
	var signCountdown string
	var signPersonalEggEnergy = "0.00"
	var signTeamEggEnergy = "0.00"
	var totalEggEnergy float64
	var estimatePersonEggEnergyValue decimal.Decimal
	var estimateTeamEggEnergyValue decimal.Decimal

	signInDb := implement.NewEggSignInDb(db.Db)
	nowStr := now.Format("2006-01-02 15:04:05")
	has, signIn, err := signInDb.EggSignINGetOneByTimeAndUid("", nowStr, user.Id, 0)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if has && utils.TimeParseStd(signIn.EndTime).After(now) {
		//3.2.1 获取预估每秒获得蛋蛋能量数
		estimatePerSecondPersonEggEnergyValue, err1 := decimal.NewFromString(signIn.EstimatePerSecondPersonEggEnergyValue)
		if err1 != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}
		estimatePerSecondTeamEggEnergyValue, err1 := decimal.NewFromString(signIn.EstimatePerSecondTeamEggEnergyValue)
		if err1 != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}
		signPersonalEggEnergy = estimatePerSecondPersonEggEnergyValue.String()
		signTeamEggEnergy = estimatePerSecondTeamEggEnergyValue.String()
		isSign = true
		signCountdown = signIn.EndTime

		//3.2.2 计算预估获得的蛋蛋能量数
		estimateTimeSec := now.Unix() - utils.TimeParseStd(signIn.StartTime).Unix()
		estimatePersonEggEnergyValue = decimal.NewFromInt(estimateTimeSec).Mul(estimatePerSecondPersonEggEnergyValue)
		estimateTeamEggEnergyValue = decimal.NewFromInt(estimateTimeSec).Mul(estimatePerSecondTeamEggEnergyValue)
	}

	// 3.3 查询个人及团队蛋蛋能量
	amountDb := implement.NewUserVirtualAmountDb(db.Db)
	personEggEnergy, err := amountDb.GetUserVirtualWalletBySession(user.Id, eggEnergyBasicSetting.PersonEggEnergyCoinId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, nil)
		return
	}
	teamEggEnergy, err := amountDb.GetUserVirtualWalletBySession(user.Id, eggEnergyBasicSetting.TeamEggEnergyCoinId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, nil)
		return
	}
	personEggEnergyValue, _ := decimal.NewFromString(personEggEnergy.Amount)
	teamEggEnergyValue, _ := decimal.NewFromString(teamEggEnergy.Amount)

	totalEggEnergy, _ = personEggEnergyValue.Add(teamEggEnergyValue).Float64()

	//4、活跃积分(个人+团队)
	var totalActivePoints float64
	personActivePoints, err := amountDb.GetUserVirtualWalletBySession(user.Id, eggEnergyBasicSetting.PersonEggPointsCoinId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	teamActivePoints, err := amountDb.GetUserVirtualWalletBySession(user.Id, eggEnergyBasicSetting.TeamEggPointsCoinId)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	totalActivePoints = utils.StrToFloat64(personActivePoints.Amount) + utils.StrToFloat64(teamActivePoints.Amount)

	//5、计算当前基础速率、团队速率
	nowBasalRate := utils.StrToFloat64(signPersonalEggEnergy) * 60 * 60 //每小时基础速率
	NowTeamRate := utils.StrToFloat64(signTeamEggEnergy) * 60 * 60      // 每小时团队速率

	userDb := implement.NewUserDb(db.Db)
	userCount, err := userDb.UserCount()
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	var residueTimes = utils.TimeParseStd(signCountdown).Unix() - time.Now().Unix()

	// 6、预估能量 + 原有能量
	totalEggEnergyDecimal := decimal.NewFromFloat(totalEggEnergy).Add(estimatePersonEggEnergyValue).Add(estimateTeamEggEnergyValue)
	// 7、总能量预估价值
	coreDataDb := implement.NewEggEnergyCoreDataDb(db.Db)
	coreData, err := coreDataDb.EggEnergyCoreDataGet()
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	nowPriceDecimal, err := decimal.NewFromString(coreData.NowPrice)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalEggEnergyValueDecimal := totalEggEnergyDecimal.Mul(nowPriceDecimal)

	utils.FilePutContents("HomePage", utils.SerializeStr(map[string]interface{}{
		"user_phone": user.Phone,
		"user_uid":   user.Id,
		"data": map[string]interface{}{
			"is_sign":              isSign,
			"sign_end_date":        signCountdown,
			"sign_end_timestamp":   utils.TimeParseStd(signCountdown).Unix(),
			"residue_times":        residueTimes,
			"total_egg_energy":     totalEggEnergyDecimal.String(),
			"total_active_points":  totalActivePoints,
			"egg_energy_now_price": nowPrice,
			"initial_price":        initialPrice,
			"is_rises":             isRise,
			"rises":                rises,
			"now_basal_rate":       nowBasalRate,
			"now_team_rate":        NowTeamRate,
			"user_count":           userCount,
			"nickname":             user.Nickname,
		},
	}))

	resp := md.HomePageResp{
		LeaveTimer:          utils.Int64ToStr(residueTimes),
		IsSign:              isSign,
		SignEndTime:         signCountdown,
		TotalEggEnergy:      totalEggEnergyDecimal.String(),
		TotalEggEnergyValue: totalEggEnergyValueDecimal.String(),
		TotalActivePoints:   utils.Float64ToStr(totalActivePoints),
		InitialPrice:        initialPrice,
		NowBasalRate:        utils.Float64ToStr(nowBasalRate),
		NowTeamRate:         utils.Float64ToStr(NowTeamRate),
		NickName:            user.Nickname,
	}

	e.OutSuc(c, resp, nil)
	return
}

// HomePageWatchAdRule
// @Summary      蛋蛋星球-主页-视频奖励规则(获取)
// @Tags         主页
// @Description  视频奖励规则(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.HomePageWatchAdRuleResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/adRule [get]
func HomePageWatchAdRule(c *gin.Context) {
	val, exists := c.Get("user")
	if !exists {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}
	user, ok := val.(*model.User)
	if !ok {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}
	// 1. 查找基础设置
	energyBasicSettingDb := implement.NewEggEnergyBasicSettingDb(db.Db)
	basicSetting, err := energyBasicSettingDb.EggEnergyBasicSettingGetOne()
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	// 2. 计算当前还能看几个广告
	recordsDb := implement.NewEggEnergyUserWatchRecordsDb(db.Db)
	records, err := recordsDb.EggEnergyUserWatchRecordsGetOneByParams(map[string]interface{}{
		"key":   "uid",
		"value": user.Id,
	})
	if err != nil {
		return
	}
	var videoRewardSystem md2.VideoRewardSystemStruct
	utils.Unserialize([]byte(basicSetting.VideoRewardSystem), &videoRewardSystem)
	redisKey := fmt.Sprintf(md2.UserNextWatchAdDate, user.Id)
	var residueWatchAdNum int
	if records == nil {
		residueWatchAdNum = utils.StrToInt(videoRewardSystem.RewardTotalNum)
	} else {
		now := time.Now()
		residueWatchAdNum = records.ResidueWatchAdNum
		if records.NextWatchAdDate.Before(now) {
			//TODO::下一轮时间已在当前时间之前
			residueWatchAdNum = utils.StrToInt(videoRewardSystem.RewardTotalNum)
			records.ResidueWatchAdNum = residueWatchAdNum
			_, err = recordsDb.EggEnergyUserWatchRecordsUpdate(records.Id, records, "residue_watch_ad_num")
			if err != nil {
				e.OutErr(c, e.ERR_DB_ORM, err.Error())
				return
			}
			cache.SetEx(redisKey, "", 60*60*24)
		}
	}
	nextWatchAdDate, _ := cache.GetString(redisKey)
	nextWatchAdTimes := utils.TimeParseStd(nextWatchAdDate).Unix() - time.Now().Unix()
	if nextWatchAdTimes < 0 {
		nextWatchAdTimes = 0
	}
	var roundRemainingSecs int64
	now := time.Now()
	//开始时间 以当前时间 往前推多少
	signInDb := implement.NewEggSignInDb(db.Db)
	nowStr := now.Format("2006-01-02 15:04:05")

	has, signIn, err := signInDb.EggSignINGetOneByTimeAndUid("", nowStr, user.Id, 0)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if has {
		roundRemainingSecs = utils.TimeParseStd(signIn.EndTime).Unix() - time.Now().Unix()
		if roundRemainingSecs < 0 {
			roundRemainingSecs = 0
		}
	}

	utils.FilePutContents("nextWatchAdDate", utils.SerializeStr(map[string]interface{}{
		"nextWatchAdDate":     nextWatchAdDate,
		"next_watch_ad_times": nextWatchAdTimes,
		"uid":                 utils.Int64ToStr(user.Id),
		"roundRemainingSecs":  roundRemainingSecs,
		"time":                time.Now().Format("2006-01-02 15:04:05.000"),
	}))

	resp := md.HomePageWatchAdRuleResp{
		RewardTotalNum:            videoRewardSystem.RewardTotalNum,
		ResidueWatchAdNum:         residueWatchAdNum,
		WatchAdRewardActivePoints: videoRewardSystem.RewardValue,
		NextWatchAdDate:           nextWatchAdDate,
		NextWatchAdSecs:           nextWatchAdTimes,
		EachRoundHour:             videoRewardSystem.EachRoundHour,
		RoundRemainingSecs:        roundRemainingSecs,
	}
	e.OutSuc(c, resp, nil)
}

const HomePageRealTimeRedisKey = "Home_Page_Real_Time_Cache_Key"

// RealTimePrice
// @Summary      蛋蛋星球-主页-实时数据(获取)
// @Tags         主页
// @Description  实时数据(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.RealTimePriceResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/realTimePrice [get]
func RealTimePrice(c *gin.Context) {
	var isRises, userCount, risesValue, nowPrice interface{}
	var rises float64
	redisKey := HomePageRealTimeRedisKey
	redisValue, err := cache.GetString(redisKey)
	if err != nil {
		if err.Error() == "redigo: nil returned" {
			now := time.Now()
			err, rises, isRises, nowPrice, _ = svc.CalcTodayEggEnergyPriceRises(db.Db, now)
			if err != nil {
				e.OutErr(c, e.ERR_DB_ORM, err.Error())
				return
			}
			userDb := implement.NewUserDb(db.Db)
			userCount, err = userDb.UserCount()
			if err != nil {
				e.OutErr(c, e.ERR_DB_ORM, err.Error())
				return
			}
			decimalRate := decimal.NewFromInt(100) //百分比
			risesValue = decimal.NewFromFloat(rises).Mul(decimalRate).StringFixed(16)

			// 缓存 5 s
			cache.SetEx(redisKey, utils.SerializeStr(map[string]interface{}{
				"user_count":           userCount,
				"is_rises":             isRises,
				"rises":                risesValue,
				"egg_energy_now_price": nowPrice,
			}), 5)
		} else {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	} else {
		var result map[string]interface{}
		err1 := json.Unmarshal([]byte(redisValue), &result)
		if err1 != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}
		userCount = result["user_count"]
		isRises = result["is_rises"]
		risesValue = result["rises"]
		nowPrice = result["egg_energy_now_price"]
	}

	isRisesResp, ok := isRises.(bool)
	if !ok {
		e.OutErr(c, e.ERR, "断言失败")
	}

	resp := md.RealTimePriceResp{
		UserCount: utils.AnyToInt64(userCount),
		NowPrice:  utils.AnyToString(nowPrice),
		IsRises:   isRisesResp,
		Rises:     utils.AnyToString(risesValue),
	}

	e.OutSuc(c, resp, nil)
}

// IsCanSignIn
// @Summary      蛋蛋星球-主页-是否能签到(获取)
// @Tags         主页
// @Description  是否可以签到(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.IsCanSignInResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/isCanSignIn [get]
func IsCanSignIn(c *gin.Context) {
	val, exists := c.Get("user")
	if !exists {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}
	user, ok := val.(*model.User)
	if !ok {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}

	now := time.Now()
	var isCan = false
	signInDb := implement.NewEggSignInDb(db.Db)
	nowStr := now.Format("2006-01-02 15:04:05")
	has, _, err := signInDb.EggSignINGetOneByTimeAndUid("", nowStr, user.Id, 0)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if has {
		isCan = false
	} else {
		//1、查找 `OneCirclesPublicPlatoonBasicSetting` 基础设置
		energyBasicSettingDb := implement.NewEggEnergyBasicSettingDb(db.Db)
		eggEnergyBasicSetting, err := energyBasicSettingDb.EggEnergyBasicSettingGetOneByParams(map[string]interface{}{
			"key":   "is_open",
			"value": 1,
		})
		if err != nil {
			e.OutErr(c, e.ERR_DB_ORM, err.Error())
			return
		}
		var videoRewardSystem *md2.VideoRewardSystemStruct
		err = json.Unmarshal([]byte(eggEnergyBasicSetting.VideoRewardSystem), &videoRewardSystem)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
		rewardTotalNum := utils.StrToInt(videoRewardSystem.RewardTotalNum)

		//2、查询当前用户观看视屏记录
		watchRecordsDb := implement.NewEggEnergyUserWatchRecordsDb(db.Db)
		userWatchRecords, err := watchRecordsDb.EggEnergyUserWatchRecordsGetOneByParams(map[string]interface{}{
			"key":   "uid",
			"value": user.Id,
		})
		if err != nil {
			e.OutErr(c, e.ERR_DB_ORM, err.Error())
			return
		}

		if userWatchRecords != nil && userWatchRecords.ResidueWatchAdNum == rewardTotalNum && userWatchRecords.NextWatchAdDate.After(now) {
			isCan = true
		}
	}

	utils.FilePutContents("HomePageIsCanSignIn", utils.SerializeStr(map[string]interface{}{
		"user_phone": user.Phone,
		"user_uid":   user.Id,
		"is_can":     isCan,
		"time":       now.Format("2006-01-02 15:04:05"),
	}))
	resp := md.IsCanSignInResp{
		IsCan: isCan,
	}
	e.OutSuc(c, resp, nil)
	return
}

// IsCanGetRedPackage
// @Summary      蛋蛋星球-主页-是否领取红包(获取)
// @Tags         主页
// @Description  是否可以领取红包(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.IsCanGetRedPackageResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/isCanGetRedPackage [get]
func IsCanGetRedPackage(c *gin.Context) {
	val, exists := c.Get("user")
	if !exists {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}
	user, ok := val.(*model.User)
	if !ok {
		e.OutErr(c, e.ERR_USER_CHECK_ERR, nil)
		return
	}

	// 1. 红包活动是否开启
	redPackageDb := implement.NewNewUserRedPackageDb(db.Db)
	redPackage, err := redPackageDb.NewUserRedPackageGetOne()
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	// 2. 用户已有红包活动记录
	userRecordsDb := implement.NewNewUserRedPackageWithUserRecordsDb(db.Db)
	records, err := userRecordsDb.NewUserRedPackageWithUserRecordsGetLastPendingByParams(map[string]interface{}{
		"key":   "uid",
		"value": user.Id,
	})
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, nil)
		return
	}

	isCan := false
	if redPackage != nil {
		if redPackage.IsOpen == 1 && records != nil {
			isCan = true
		}
	}
	resp := md.IsCanGetRedPackageResp{
		IsCan: isCan,
	}
	e.OutSuc(c, resp, nil)
}

const HeroListRedisRankKey = "EggEnergy:HomePage:HeroList:Rank:%d" //  1.kind
// HeroList
// @Summary      蛋蛋星球-主页-英雄榜(获取)
// @Tags         主页
// @Description  英雄榜(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    kind    query	 string  true "时间类型：1.天 2.周 3.月"
// @Param    page    query	 string  true "页数"
// @Success      200   {object}   md.IsCanGetRedPackageResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/heroList [get]
func HeroList(c *gin.Context) {
	kind := utils.StrToInt(c.DefaultQuery("kind", "1"))
	page := utils.StrToInt(c.DefaultQuery("page", "1"))
	limit := 10
	start := (page - 1) * limit
	end := start + limit - 1

	rankCacheKey := fmt.Sprintf(HeroListRedisRankKey, kind)
	// 1. 获取指定范围的排行
	results, err := cache.ZRevRange(rankCacheKey, start, end, true)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	// 2. 查询排行内用户头像和昵称
	total := len(results)
	list := make([]md.HeroListNode, total/2)
	userIds := make([]string, total/2)
	for i, result := range results {
		if i%2 == 1 {
			// 奇数数据是分数
			list[(i-1)/2].SumValue = string(result.([]uint8))
		} else {
			// 偶数数据是 uid
			list[i/2] = md.HeroListNode{
				AvatarUrl: "",
				SumValue:  "",
				Uid:       string(result.([]uint8)),
				Nickname:  "",
			}
			userIds = append(userIds, string(result.([]uint8)))
		}
	}
	userDb := implement.NewUserDb(db.Db)
	users, err := userDb.UserFindByParams(map[string]interface{}{
		"key":   "id",
		"value": userIds,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	userMap := make(map[int64]model.User, len(users))
	for _, user := range users {
		userMap[user.Id] = user
	}

	for i, node := range list {
		val, ok := userMap[utils.StrToInt64(node.Uid)]
		if ok {
			list[i].Nickname = val.Nickname
			list[i].AvatarUrl = svc.GetOssUrl(val.Avatar)
		}
	}

	// 3. 查询当前用户排名信息
	var rank int64
	var score string
	var err1 error
	user := svc.GetUser(c)
	rank, err1 = cache.ZRevRangeByMember(rankCacheKey, utils.Int64ToStr(user.Id))
	if err1 != nil {
		if err1.Error() != "redigo: nil returned" {
			e.OutErr(c, e.ERR, err1.Error())
			return
		} else {
			// 3.1 当前用户不在排行榜上
			aggregationDb := implement.NewUserVirtualCoinFlowAggregationDb(db.Db)
			flowAggregation, err := aggregationDb.UserVirtualCoinFlowAggregationGetOneByParams(map[string]interface{}{
				"key":   "uid",
				"value": user.Id,
			})
			if err != nil {
				e.OutErr(c, e.ERR_DB_ORM, err.Error())
				return
			}
			if flowAggregation != nil {
				switch kind {
				case 1:
					score = flowAggregation.TodayData
				case 2:
					score = flowAggregation.ThisWeekData
				case 3:
					score = flowAggregation.ThisMonthData
				}
			} else {
				score = "0"
			}
		}
	} else {
		// 3.2 该用户在排行榜上
		scoreNum, err2 := cache.ZScoreByMember(rankCacheKey, utils.Int64ToStr(user.Id))
		if err2 != nil {
			if err2.Error() != "redigo: nil returned" {
				e.OutErr(c, e.ERR, err2.Error())
				return
			}
		}
		// redis 排名从 0 开始
		rank++
		score = utils.Float64ToStr(scoreNum)
	}

	selfRank := md.SelfHeroListNode{
		AvatarUrl: svc.GetOssUrl(user.Avatar),
		SumValue:  score,
		Uid:       user.Id,
		Nickname:  user.Nickname,
		Rank:      rank,
	}

	resp := md.HeroListResp{
		Total:    100,
		Page:     page,
		Limit:    10,
		SelfRank: selfRank,
		List:     list,
	}
	e.OutSuc(c, resp, nil)
}

// StarRoadProgress
// @Summary      蛋蛋星球-主页-星球之路升级条件(获取)
// @Tags         主页
// @Description  星球之路升级条件(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.StarRoadProgressResp  	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/v1/homePage/starRoad [get]
func StarRoadProgress(c *gin.Context) {
	user := svc.GetUser(c)

	// 1. 获取等级列表
	levelDb := implement.NewUserLevelDb(db.Db)
	levels, err := levelDb.UserLevelAllByAsc()
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	// 2. 获取下一等级信息
	var nextLevel *model.UserLevel
	var currentLevelName string
	for i, level := range levels {
		if level.Id == user.Level {
			if i < len(levels)-1 {
				nextLevel = levels[i+1]
			}
			currentLevelName = level.LevelName
		}

	}

	var list []md.LevelTaskNode
	// 3. 判断是否已达到最高等级
	if nextLevel != nil {
		// 4. 获取下一等级任务信息
		taskDb := implement.NewUserLevelTaskDb(db.Db)
		levelTasks, err := taskDb.UserLevelTaskFindByParams(map[string]interface{}{
			"key":   "level_id",
			"value": nextLevel.Id,
		})
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
		now := time.Now()
		// 5. 统计完成任务数
		for _, levelTask := range levelTasks {
			var count int64
			var err1 error
			// 5.1 判断任务是否完成
			switch levelTask.TaskType {
			case 1:
				_, count, err1 = svc.IsFinishDirectPush(user.Id, levelTask.FinishCount)
			case 2:
				_, count, err1 = svc.IsFinishDirectPushOfActiveDays(user.Id, levelTask.FinishCount, levelTask.ActiveDays, now, levelTask.WithinDays)
			case 3:
				_, count, err1 = svc.IsFinishDirectPushLevel(user.Id, levelTask.LevelId, levelTask.FinishCount)
			}
			if err1 != nil {
				e.OutErr(c, e.ERR_DB_ORM, err1.Error())
				return
			}
			task := md.LevelTaskNode{
				LevelId:         levelTask.LevelId,
				IsMustTask:      levelTask.IsMustTask,
				TaskType:        levelTask.TaskType,
				WithinDays:      levelTask.WithinDays,
				FinishCount:     levelTask.FinishCount,
				ActiveDays:      levelTask.ActiveDays,
				TaskTypeLevelId: levelTask.TaskType,
				FinishNum:       count,
			}
			list = append(list, task)
		}
	}

	resp := md.StarRoadProgressResp{
		LevelName: currentLevelName,
		LevelId:   user.Level,
		List:      list,
	}
	e.OutSuc(c, resp, nil)
}