package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"math/rand"
	"sort"
	"strconv"
	"time"
)

//生成数字
func GenerateNums(start, end, count int) []int {
	var nums []int
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	for len(nums) < count {
		//生成随机数
		num := r.Intn((end - start)) + start + 1
		//查重
		exist := false
		for _, v := range nums {
			if v == num {
				exist = true
				break
			}
		}
		if !exist {
			nums = append(nums, num)
		}
	}
	return nums
}

//生成新的一期初始化奖池随机数
func NewCaiPiaoRound(start, end, count, round int) {
	nums := GenerateNums(start, end, count)
	//存入redis
	fakenum := GetCaiPiaoFake(round)
	var curround CurDuboCatList
	curround.CurRound = round
	curround.CurNum = 0
	curround.FakeNum = fakenum
	logger.Info("SetCurCaiCatList")
	SetCurCaiCatList(&curround)

	//首先清楚原先的号码
	redishandler.GetRedisClient().Delete(redis.CAIPIAOLEFTNUM_KEY)
	for _, val := range nums {
		if fakenum == val {
			continue
		}
		redishandler.GetRedisClient().HSet(redis.CAIPIAOLEFTNUM_KEY, strconv.Itoa(val), strconv.Itoa(val))
	}
}

//获取已开奖赌博猫列表
func GetWaitCaiCatList() []WaitDuboCatList {
	var rtsl []WaitDuboCatList
	vv, err := redishandler.GetRedisClient().HGetAllValues(redis.CAIPIAOKAIJIANGWAIT_KEY)
	if err != nil {
		//logger.Error("GetTeamListByCond err")
		return rtsl
	}

	for _, val := range vv {
		//one := new(WaitDuboCatList)
		var one WaitDuboCatList
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, &one)
		if err == nil {
			rtsl = append(rtsl, one)
		}
	}
	return rtsl
}

//获取正在投注的赌博猫池子列表
func GetCurCaiCatList() *CurDuboCatList {
	curstr, err := redishandler.GetRedisClient().GetString(redis.CAIPIAOKAIJIANGCURRENT_KEY)
	if err != nil {
		return nil
	}
	prt := new(CurDuboCatList)
	err = json.Unmarshal([]byte(curstr), prt)
	if err != nil {
		logger.Error("GetCurCaiCatList err=%v", err)
		return nil
	}
	return prt
}

//设置当前彩池
func SetCurCaiCatList(c *CurDuboCatList) {
	logger.Info("SetCurCaiCatList")
	savestr, err := json.Marshal(c)
	if err != nil {
		logger.Error("SetCurCaiCatList err=%v", err)
	}

	err = redishandler.GetRedisClient().SetString(redis.CAIPIAOKAIJIANGCURRENT_KEY, string(savestr))
	if err != nil {
		logger.Error("SetCurCaiCatList err=%v", err)
	}
}

//赌博猫开奖真假接口 返回非零表示当期作弊号码
func GetCaiPiaoFake(round int) int {
	numstr, err := redishandler.GetRedisClient().HGet(redis.CAIPIAOISFAKE_KEY, strconv.Itoa(round))
	if err != nil {
		return 0
	}
	rtnum, err := strconv.Atoi(numstr)
	if err != nil {
		logger.Error("GetCaiPiaoFake failede err=%v", err)
		return 0
	}
	return rtnum
}

func SetCaiPiaoFake(num, round int) {
	err := redishandler.GetRedisClient().HSet(redis.CAIPIAOISFAKE_KEY, strconv.Itoa(round), strconv.Itoa(num))
	if err != nil {
		logger.Error("SetCaiPiaoFake err=%v", err)
	}
}

//加红包接口
func (u *UserData) AddRedPackect(num float32) {
	//todo 接后台
	u.Redbag += num
}

//清空一个位置的猫
func (u *UserData) CleadPos(pos int) {
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return
	}

	u.PosInfo[pos].Cat = 0
	u.PosInfo[pos].Position = pos
	u.PosInfo[pos].StartTime = 0
	u.PosInfo[pos].RedPacket = 0
	u.PosInfo[pos].Time = 0
}

//设置一个位置的猫
func (u *UserData) SetCatPos(pos int, catlv, time int, redpack float32, starttime int) {
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return
	}

	u.PosInfo[pos].Cat = catlv
	u.PosInfo[pos].Position = pos
	u.PosInfo[pos].StartTime = starttime
	u.PosInfo[pos].RedPacket = redpack
	u.PosInfo[pos].Time = time
}

//获取所有分红猫列表的位置
func (u *UserData) GetLimitCatList() []int {
	var rtlist []int
	for k, v := range u.PosInfo {
		if v.Cat > 36 {
			rtlist = append(rtlist, k)
		}
	}

	return rtlist
}

//根据猫等级获得位置
func (u *UserData) GetCatPos(catlv int) int {
	pos := -1
	for _, v := range u.PosInfo {
		if v.Cat == catlv {
			pos = v.Position
		}
	}

	if pos < 0 || pos >= len(u.PosInfo) {
		pos = -1
	}
	return pos
}

//转盘抽奖 返回抽到的奖项的id
func (u *UserData) DrawTable() int {
	idx := 1
	if u.DrawTableCount != 3 {
		//抽a类型
		sumrate := float32(0)
		tmprate := 0
		rand.Seed(time.Now().UnixNano())
		randnum := rand.Intn(100)
		cflist := jsonconf.GetTurnTable(1)
		for _, vv := range cflist {
			sumrate += vv.Rate
		}
		logger.Info("DrawTable sumrate=%v,randnum=%v,cflist=%+v", sumrate, randnum, cflist)
		for _, v := range cflist {
			tmprate += int(v.Rate * 100 / sumrate)
			logger.Info("DrawTable tmprate=%v", tmprate)
			if tmprate >= randnum {
				idx = v.Id
				break
			}
		}

	} else {
		//抽b类型
		sumrate := float32(0)
		tmprate := 0
		rand.Seed(time.Now().UnixNano())
		randnum := rand.Intn(100)
		cflist := jsonconf.GetTurnTable(2)
		for _, vv := range cflist {
			sumrate += vv.Rate
		}

		logger.Info("DrawTable sumrate=%v,randnum=%v,cflist=%+v", sumrate, randnum, cflist)
		if len(cflist) > 0 {
			idx = cflist[0].Id
		}
		for _, v := range cflist {
			tmprate += int(v.Rate * 100 / sumrate)
			logger.Info("DrawTable tmprate=%v", tmprate)
			if tmprate >= randnum {
				idx = v.Id
				break
			}
		}
	}

	logger.Info("DrawTable idx=%v", idx)
	return idx
}

func (u *UserData) DoFlopCardd(resp *DoFlopResp) {
	cfg := jsonconf.GetCardConfig(u.FlopCardCnt)
	if cfg == nil {
		logger.Error("HandlerDoFlop getcfg failed=%v", u.FlopCardCnt)
		resp.Code = 1
		resp.Message = "getcfg"
		return
	}

	logger.Info("DoFlopCardd cfg=%+v", cfg)
	addgold := int64(0)
	var catfg *jsonconf.RedCatDesc
	catid := 0
	ctime := 0
	nowt := int(time.Now().Unix())
	switch cfg.Ctype {
	case FLOPTYPE_15MIN:
		addgold = u.Goldrate * 15 * 60

	case FLOPTYPE_45MIN:
		addgold = u.Goldrate * 45 * 60
	case FLOPTYPE_FENCAT15MIN:
		catid = 14 + REDCATIDEXTRA
		ctime = 15 * 60
		catfg = jsonconf.GetRedCatConfig(catid)
		u.SetRedCatPos(catid, ctime, catfg.Money, nowt)
	case FLOPTYPE_FENCAT10MIN:
		catid = 13 + REDCATIDEXTRA
		ctime = 10 * 60
		catfg = jsonconf.GetRedCatConfig(catid)
		u.SetRedCatPos(catid, ctime, catfg.Money, nowt)
	case FLOPTYPE_REDCAT:
		catid = 10 + REDCATIDEXTRA
		catfg = jsonconf.GetRedCatConfig(catid)
		u.SetRedCatPos(catid, 0, catfg.Money, 0)
	case FLOPTYPE_GLAMCAT:
		catid = 11 + REDCATIDEXTRA
		catfg = jsonconf.GetRedCatConfig(catid)
		u.SetDuboCatPos(catid)
	}
	u.Gold += addgold
	u.CalcGoldRate()

	u.FlopCardLefCnt--
	u.FlopCardCnt++

	SaveUserInfo(u, strconv.Itoa(u.UserId))

	resp.Data.LeftTimes = u.FlopCardLefCnt
	resp.Data.Coin.UserId = u.UserId
	resp.Data.Coin.Coin = strconv.FormatInt(u.Gold, 10)
	resp.Data.Coin.IcomeRate = strconv.FormatInt(u.Goldrate, 10)
	resp.Data.Coin.UpdateTime = int(time.Now().Unix())

	resp.Data.Reward.RewardId = u.FlopCardCnt - 1
	resp.Data.Reward.Coin = strconv.FormatInt(addgold, 10)
	resp.Data.LeftTimes = u.FlopCardLefCnt

	logger.Info("DoFlopCardd resp=%+v", resp)
}

func (u *UserData) HandlePassDay() {
	isdiffday := false
	nowtime := time.Now()
	lasttime := time.Unix(int64(u.LastLoginTime), 0)
	nowdaynum := time.Now().Day()
	lastdaynum := time.Unix(int64(u.LastLoginTime), 0).Day()
	nowtimestamp := time.Date(nowtime.Year(), nowtime.Month(), nowtime.Day(), 0, 0, 0, 0, nowtime.Location())
	lasttimestamp := time.Date(lasttime.Year(), lasttime.Month(), lasttime.Day(), 0, 0, 0, 0, lasttime.Location())

	logger.Info("HandlePassDay lasttime=%v,lasttimestamp=%v", lasttime, lasttimestamp)
	if nowdaynum == lastdaynum {
		//同一天
		if int64(u.LastLoginTime)-time.Now().Unix() > 86400 {
			//已经过了很多天了

			isdiffday = true
		} else {
			//t同一天 不做处理
		}
	} else {
		//不是同一天了
		isdiffday = true
		if nowtimestamp.Unix() != lasttimestamp.Unix()+86400 {

		} else {

		}
		logger.Info("HandlePassDay now=%v,last=%v", nowtimestamp.Unix(), lasttimestamp.Unix())
	}

	if isdiffday {
		//跨天了
		u.DoubleLeftTimes = ACCGOLDRATELIMIT
		u.GetWatchAdsGoldTime = WATCHADSGOLDLIMIT
		u.DrawTicket = DRAWTICKETNUM
		u.DrawTicketTimes = DRAWTICKETGETLIMIT
	}

	u.LastLoginTime = int(nowtime.Unix())

	SaveUserInfo(u, strconv.Itoa(u.UserId))
}

func SaveUserInfo(data *UserData, uniqueid string) error {

	savestr, err := json.Marshal(data)
	if err != nil {
		return err
	}

	err = redishandler.GetRedisClient().HSet(redis.USER_INFO__KEY, uniqueid, string(savestr))

	return err
}

func GetUserInfo(uid string) (*UserData, error) {

	data, err := redishandler.GetRedisClient().HGet(redis.USER_INFO__KEY, uid)
	if err != nil {
		return nil, err
	}
	var tmp UserData
	err = json.Unmarshal([]byte(data), &tmp)
	if err != nil {
		return nil, err
	}

	return &tmp, nil
}

//初始化玩家信息
func InitUserInfo(data *UserLoginReq, resp *UserLoginResp, uuid int) {
	udata := new(UserData)
	udata.UserId = data.UserId
	udata.Gold = 0
	udata.GoldSum += udata.Gold
	udata.Love = 0
	udata.InviteId = data.Fromid
	udata.Highestlv = 0
	udata.CurBoxLv = 1
	udata.IsDouble = 0
	udata.IsAuto = 0
	udata.IsBoxAcc = 0
	udata.RandGiftDay = time.Now().Day()
	udata.RandGiftNum = 6
	udata.RandGiftTime = int(time.Now().Unix())
	udata.Redbag = 0
	udata.IsFirstRedBgCat = 0
	udata.DoubleLeftTimes = ACCGOLDRATELIMIT
	udata.GetWatchAdsGoldTime = WATCHADSGOLDLIMIT
	udata.RegTime = int(time.Now().Unix())
	udata.LastLoginTime = int(time.Now().Unix())
	udata.DrawTicket = DRAWTICKETNUM
	udata.DrawTicketTimes = DRAWTICKETGETLIMIT
	udata.DratMult = 1
	udata.DrawTableCount = 1
	udata.FlopCardCnt = 1
	//test
	udata.FlopCardLefCnt = 100

	//初始化16个猫爬架
	for i := 0; i < 16; i++ {
		var d1 CatPosInfo
		d1.Position = i

		d1.Cat = 0
		//d1.Cat = 18
		if i < 4 {
			d1.Cat = 1
		}
		udata.PosInfo = append(udata.PosInfo, d1)
		var d2 DataDesc
		d2.Pos = i
		d2.Catlv = 0

	}

	udata.Loverate = 0
	udata.CalcGoldRate()

	//初始化商店信息
	initcatcfg := jsonconf.GetCatConfig(1)
	if initcatcfg == nil {
		logger.Error("get 1catcfg err")
		return
	}
	var info BuyCatInfoData
	info.Buytime = 0
	info.CurPrice, _ = strconv.ParseInt(initcatcfg.Price, 10, 64)
	info.IsMaxBuytime = 0
	udata.BuyCatInfo = append(udata.BuyCatInfo, info)

	//初始化猫咖门店数据
	udata.CatShopInfo.LeftTime = 0
	udata.CatShopInfo.Chapter = 1
	udata.CatShopInfo.DayNum = time.Now().Day()
	udata.CatShopInfo.IsPlaying = 0
	udata.CatShopInfo.PlayTimes = 0
	udata.CatShopInfo.Section = 1
	udata.CatShopInfo.ThisIsWatch = 0
	udata.CatShopInfo.TotalWatchNumLeft = 8 //

	logger.Info("Init user data=%v", udata)

	resp.Data.Nickname = udata.NickName
	resp.Data.UserId = strconv.Itoa(udata.UserId)
	resp.Data.AccessToken = ""
	resp.Data.HeadImg = udata.Head
	resp.Data.LoginType = data.Lype

	//保存redis
	SaveUserInfo(udata, strconv.Itoa(uuid))

	//初始化玩家仓库信息
	pware := new(UserWareHouseData)
	for i := 0; i < 15; i++ {
		var tmp WareHouseDesc
		tmp.Warelv = 0
		pware.Info = append(pware.Info, tmp)
	}
	wares, err := json.Marshal(pware)
	if err != nil {
		logger.Info("InitUserInfo warehouse failed err=%v", err)
	}
	redishandler.GetRedisClient().HSet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid), string(wares))

	//保存此次计算时间
	nowtimestr := strconv.Itoa(int(time.Now().Unix()))
	redishandler.GetRedisClient().HSet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid), nowtimestr)
}

//设置赌博猫
func (u *UserData) SetDuboCatPos(catlv int) {

	var du DuboCatInfo
	du.ChooseNum = 0
	du.CatID = catlv
	u.DuboCat = append(u.DuboCat, du)
}

//设置红包猫
func (u *UserData) SetRedCatPos(catlv, time int, redpack float32, starttime int) {
	pos := getCatPutPos(u, catlv)
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return
	}

	u.PosInfo[pos].Cat = catlv
	u.PosInfo[pos].Position = pos
	u.PosInfo[pos].StartTime = starttime
	u.PosInfo[pos].RedPacket = redpack
	u.PosInfo[pos].Time = time
}

//计算购买后猫箱子的位置，将箱子放到对应位置 返回值表示位置 -1表示失败都满了
func getCatPutPos(uinfo *UserData, clv int) int {
	pos := -1
	for k, v := range uinfo.PosInfo {
		if v.Cat == 0 {
			uinfo.PosInfo[k].Cat = clv
			uinfo.PosInfo[k].Position = k
			//v.Catlv = clv
			//v.Pos = k
			pos = k
			break
		}
	}
	return pos
}

//处理红包猫自动合成
func DoAutoMergeRedCat(uinfo *UserData, uuid int) {
	return //需要主动请求
	//首先处理五方招财猫逻辑
	eastsum := 0
	westsum := 0
	southsum := 0
	northsum := 0
	middlesum := 0

	for _, v := range uinfo.PosInfo {
		if v.Cat == 103 {
			eastsum++
		}
		if v.Cat == 104 {
			westsum++
		}
		if v.Cat == 105 {
			southsum++
		}
		if v.Cat == 106 {
			northsum++
		}
		if v.Cat == 107 {
			middlesum++
		}

	}

	//五方猫
	if eastsum > 0 && westsum > 0 && northsum > 0 && southsum > 0 && middlesum > 0 {
		//合成一天招财猫
		//首先去除五只猫
		onepos := -1
		for k, v := range uinfo.PosInfo {
			if v.Cat == 103 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 104 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 105 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 106 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 107 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		if onepos < 0 {
			logger.Error("DoAutoMergeRedCat failed onepos=%v", onepos)
		}
		uinfo.PosInfo[onepos].Cat = 102 //1天招财猫
		cfg := jsonconf.GetRedCatConfig(uinfo.PosInfo[onepos].Cat)
		if cfg == nil {
			logger.Error("DoAutoMergeRedCat getrdcfg failed lv=%v", uinfo.PosInfo[onepos].Cat)
		} else {
			uinfo.PosInfo[onepos].Time = 24 * 60 * 60
			uinfo.PosInfo[onepos].RedPacket = cfg.Money
			uinfo.PosInfo[onepos].StartTime = int(time.Now().Unix())
			uinfo.PosInfo[onepos].Position = onepos
		}

	}

}

//合成红包猫 返回红包猫等级 等级为red_catconfig的id+100
func MergeRedBagCat(uinfo *UserData, pos int) int {
	rtpos := 0

	//走随机合成逻辑
	sumrate := float32(0)
	for _, v := range jsonconf.GetJsonConf().RedCatConfig {
		sumrate += v.Rate
	}
	rand.Seed(time.Now().UnixNano())
	randnum := rand.Intn(100)
	tmprate := 0
	for _, v := range jsonconf.GetJsonConf().RedCatConfig {
		tmprate += int(v.Rate * 100 / sumrate)
		if tmprate >= randnum {
			uinfo.PosInfo[pos].Position = pos
			uinfo.PosInfo[pos].Cat = REDCATIDEXTRA + v.Id
			if v.Id == 13 {
				uinfo.PosInfo[pos].Time = 10 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			if v.Id == 14 {
				uinfo.PosInfo[pos].Time = 15 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			if v.Id == 2 {
				uinfo.PosInfo[pos].Time = 24 * 60 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			uinfo.PosInfo[pos].RedPacket = v.Money
			rtpos = pos
			break
		}
	}

	//翻拍次数+
	uinfo.FlopCardLefCnt++
	return rtpos
}

func (uinfo *UserData) CheckBuyCatSHop() {
	//检查可购买的猫是否会增加
	//需要扩充一下商店
	curshoplv := len(uinfo.BuyCatInfo)
	if uinfo.Highestlv-5 > curshoplv {
		var info BuyCatInfoData
		info.Buytime = 0
		cafcfg := jsonconf.GetCatConfig(uinfo.Highestlv - 5)
		if cafcfg != nil {
			info.CurPrice, _ = strconv.ParseInt(cafcfg.Price, 10, 64)
		}
		info.IsMaxBuytime = 0
		uinfo.BuyCatInfo = append(uinfo.BuyCatInfo, info)
	}
}

func (udata *UserData) CalcGoldRate() int64 {
	//计算出所有速率的和
	//计算方式为 首先计算合成界面猫的产出速率，然后计算红毛包的产出速率，最后计算仓库中的猫的产出速率
	var sumrate int64
	cfg37 := jsonconf.GetCatConfig(37)
	if cfg37 == nil {
		logger.Error("37cfg err!!")
		return 0
	}
	for _, v := range udata.PosInfo {
		if v.Cat > 0 && v.Cat < REDCATIDEXTRA {
			//有猫存在的要计算一下
			//非红包猫
			for _, vv := range jsonconf.GetJsonConf().CatConfig {
				if vv.Id == v.Cat {
					onerate, _ := strconv.ParseInt(vv.Gold_get, 10, 64)
					sumrate += onerate
					break
				}
			}
		}

		if v.Cat > REDCATIDEXTRA {
			//红包猫  需要判断是否产金币
			rcfg := jsonconf.GetRedCatConfig(v.Cat)
			if rcfg != nil {
				if rcfg.Is_37 != 0 {
					onerate, _ := strconv.ParseInt(cfg37.Gold_get, 10, 64)
					sumrate += onerate
				}
			} else {
				logger.Error("GetRedCatConfig failed lv=%v", v.Cat)
			}
		}
	}

	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(udata.UserId))
	if err != nil {
		logger.Error("CalcGoldRate failed err=%v", err)
		return sumrate
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcGoldRate Unmarshal redis failed ")
		return sumrate
	}
	for _, v := range wdata.Info {
		if v.Warelv == 0 {
			continue
		}
		rcfg := jsonconf.GetRedCatConfig(v.Warelv)
		if rcfg != nil {
			if rcfg.Is_37 != 0 {
				onerate, _ := strconv.ParseInt(cfg37.Gold_get, 10, 64)
				sumrate += onerate
			}
		} else {
			logger.Error("GetRedCatConfig failed lv=%v", v.Warelv+REDCATIDEXTRA)
		}
	}

	udata.Goldrate = sumrate
	return sumrate
}

//发生金币变动时保存排行榜
func (udata *UserData) AddToRank() error {
	err := redishandler.GetRedisClient().Zadd(redis.USER_GOLD_RANK, float64(udata.GoldSum), strconv.Itoa(udata.UserId))
	if err != nil {
		logger.Error("AddToRank failed err=%v", err)
	}
	return err
}

//计算最高等级猫的名字
func (u *UserData) CalcHigestCatName() string {
	higestlv := 0
	for _, val := range u.PosInfo {
		if higestlv < val.Cat {
			higestlv = val.Cat
		}
	}

	//计算仓库内的
	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(u.UserId))
	if err != nil {
		logger.Error("CalcHigestCatName failed err=%v", err)
		return ""
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcHigestCatName Unmarshal redis failed ")
		return ""
	}
	for _, val := range wdata.Info {
		reallv := val.Warelv
		if higestlv < reallv {
			higestlv = reallv
		}
	}

	//计算猫名字
	if higestlv > 100 {
		cfg := jsonconf.GetRedCatConfig(higestlv - 100)
		if cfg == nil {
			logger.Error("CalcHigestCatName failed getcfg higestlv=%v", higestlv)
			return ""
		}
		return cfg.Name
	} else {
		cfg := jsonconf.GetCatConfig(higestlv)
		if cfg == nil {
			logger.Error("CalcHigestCatName failed getcfg higestlv=%v", higestlv)
			return ""
		}
		return cfg.Name
	}

}

//获取红包猫列表
func (u *UserData) GetRedCatIdList() []int {
	var rtsl []int
	for _, val := range u.PosInfo {
		if val.Cat > 100 {
			rtsl = append(rtsl, val.Cat-100)
		}
	}

	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(u.UserId))
	if err != nil {
		logger.Error("CalcGoldRate failed err=%v", err)
		return rtsl
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcGoldRate Unmarshal redis failed ")
		return rtsl
	}
	for _, val := range wdata.Info {
		rtsl = append(rtsl, val.Warelv)
	}

	if len(rtsl) > 16 {
		sort.Ints(rtsl)
		return rtsl[:len(rtsl)-16]
	} else {
		return rtsl
	}

}

//尝试将合成界面的猫放入仓库 返回位置索引 -1表示仓库已满放入失败
func (u *UserData) tryPutToWareHouse(info *UserWareHouseData, pos int, uuid int) int {
	rtval := -1
	for k, v := range info.Info {
		if v.Warelv == 0 {
			rtval = k
			info.Info[k].Warelv = u.PosInfo[pos].Cat
			info.Info[k].Time = u.PosInfo[pos].Time
			info.Info[k].RedPacket = u.PosInfo[pos].RedPacket
			info.Info[k].StartTime = u.PosInfo[pos].StartTime
			//v.Warelv = lv

			break
		}
	}
	if rtval != -1 {
		wares, _ := json.Marshal(info)
		redishandler.GetRedisClient().HSet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid), string(wares))
	}
	return rtval
}

//根据id获得仓位位置
func (w *UserWareHouseData) GetWarePosById(cid int) int {
	for k, v := range w.Info {
		if v.Warelv == cid {
			return k
		}
	}
	return -1
}