package logic

import (
	"HttpServer/conf"
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"bytes"
	"common/logger"
	"common/redis"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"io/ioutil"
	"math/rand"
	"net/http"
	"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) GenerateFlyBoxID() int {
	sumrate := 0
	tmprate := 0

	rand.Seed(time.Now().UnixNano())
	randnum := rand.Intn(100)
	cflist := jsonconf.GetJsonConf().BoxConfig
	if len(cflist) == 0 {
		logger.Error("GenerateFlyBoxID len failed ")
		return 0
	}
	idx := cflist[0].Id
	for _, vv := range cflist {
		sumrate += vv.Rate
	}
	for _, v := range cflist {
		tmprate += int(v.Rate * 100 / sumrate)
		logger.Info("GenerateFlyBoxID randnum=%v tmprate=%v", randnum, tmprate)
		if tmprate >= randnum {
			idx = v.Id
			break
		}
	}

	return idx
}

//计算生成的箱子id
func (u *UserData) GenerateBox() int {
	sumrate := 0
	tmprate := 0

	rand.Seed(time.Now().UnixNano())
	randnum := rand.Intn(100)
	cflist := jsonconf.GetJsonConf().GiftConfig
	if len(cflist) == 0 {
		logger.Error("CalcBoxId len failed ")
		return 0
	}
	idx := cflist[0].Id
	for _, vv := range cflist {
		sumrate += vv.Rate
	}
	for _, v := range cflist {
		tmprate += int(v.Rate * 100 / sumrate)
		if tmprate >= randnum {
			idx = v.Id
			break
		}
	}

	u.PosInfo[BOXGIFTPOS].Cat = idx + BOXGIFTEXTRA
	SaveUserInfo(u, strconv.Itoa(u.UserId))
	return idx
}

//计算领取随机红包值
func (u *UserData) CalcRandRedBagNum() float32 {
	//todo 用公式计算
	rand.Seed(time.Now().UnixNano())
	addnum := float32(0)
	if u.SumRandRedBagTimes <= 10 {
		addnum = float32(rand.Intn(30))/100 + 0.2
	} else if u.SumRandRedBagTimes > 10 && u.SumRandRedBagTimes <= 20 {
		addnum = float32(rand.Intn(30))/100 + 0.1
	} else if u.SumRandRedBagTimes > 20 && u.SumRandRedBagTimes <= 30 {
		addnum = float32(rand.Intn(20))/100 + 0.1
	} else if u.SumRandRedBagTimes > 30 && u.SumRandRedBagTimes <= 100 {
		addnum = float32(rand.Intn(20)) / 100
	} else {
		addnum = float32(rand.Intn(10)) / 100
	}

	return addnum
}

//加红包接口
func (u *UserData) AddRedPackect(num float32, atype int) (int, error) {
	SERVERKEY := conf.GetCoinConf().Key
	goldnum := int(num * 10000)
	var paramlist []string
	sign_type := "sign_type=md5"
	paramlist = append(paramlist, sign_type)
	time_stamp := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramlist = append(paramlist, time_stamp)
	paramgameid := "gameid=" + u.Gameid
	paramlist = append(paramlist, paramgameid)
	pchannel := "channel=" + u.Channel
	paramlist = append(paramlist, pchannel)
	puid := "uid=" + strconv.Itoa(u.UserId)
	paramlist = append(paramlist, puid)
	pcoin := "coin=" + strconv.Itoa(goldnum)
	paramlist = append(paramlist, pcoin)
	ptyp := "typ=" + strconv.Itoa(atype)
	paramlist = append(paramlist, ptyp)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY
	logger.Info("AddCoinToSdk sumparam=%v", signsum)

	//进行hash
	sign := GetHashValue(signsum)

	var req AddCoinDesc
	req.Channel = u.Channel
	req.Gameid = u.Gameid
	req.Coin = goldnum
	req.Sign = sign
	req.Sign_type = "md5"
	req.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	req.Typ = atype
	req.Uid = u.UserId

	bys, err := json.Marshal(&req)
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, err
	}
	res, err := DoHttpPost(bys, "api/server/addcoin")
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, err
	}

	logger.Info("AddCoinToSdk res=%v", res)
	var resp AddCoinResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, err
	}

	if resp.Code != "0" {
		gold, _ := GetCoinFromSdk(u.UserId, u.Gameid, u.Channel)
		logger.Error("AddCoinToSdk failed=%v", resp.Msg)
		return gold, err
	}
	return resp.Data.Mycoin, nil

}

//清空一个位置的猫
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 && v.Cat < 1000 {
			rtlist = append(rtlist, k)
		}
	}

	return rtlist
}

//查询是否有空位
func (u *UserData) HasEmptyPos() bool {
	for _, v := range u.PosInfo {
		if v.Cat == 0 {
			return true
		}
	}
	return false
}

//根据猫等级获得位置
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.GoldSum += 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 u.IsResetToday == 0 && nowtimestamp.Hour() >= 12 {
		u.DoubleLeftTimes = ACCGOLDRATELIMIT
		u.GetWatchAdsGoldTime = WATCHADSGOLDLIMIT
		u.DrawTicket = DRAWTICKETNUM
		u.DrawTicketTimes = DRAWTICKETGETLIMIT
		//u.RandRedBagLeftTime = RANDGIFTLIMIT
		//u.FlyBoxNumTimes = FLYBOXNUMLIMIT
		//u.LeftTimingRewardTimes = TIMEINGREWARDLIMIT
		//u.LeftOfflineTimes = OFFLINETIMESLIMIT
		//u.EmptyBoxLeftTime = EMPTYBOXLIMIT
		u.IsResetToday = 1
	}
	if nowdaynum == lastdaynum {

		//同一天
		if int64(u.LastLoginTime)-time.Now().Unix() > 86400 {
			//已经过了很多天了

			u.ContinueLoginDay = 1
			u.SumLoginDay++

		} else {
			//t同一天 不做处理
		}
	} else {
		//不是同一天了
		isdiffday = true
		if nowtimestamp.Unix() != lasttimestamp.Unix()+86400 {
			u.ContinueLoginDay = 1
			u.SumLoginDay++
		} else {
			u.ContinueLoginDay++
		}
		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.RandRedBagLeftTime = RANDGIFTLIMIT
		u.FlyBoxNumTimes = FLYBOXNUMLIMIT
		u.LeftTimingRewardTimes = TIMEINGREWARDLIMIT
		u.LeftOfflineTimes = OFFLINETIMESLIMIT
		u.EmptyBoxLeftTime = EMPTYBOXLIMIT

		u.IsResetToday = 0
		/*randint := rand.Intn(100)
		floatval := float32(randint) / 100
		u.TodayZhaocai = 180 + floatval*/
	}

	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 (uinfo *UserData) GetWithDrawData(money float32) (int, *WithDrawDesc) {
	//处理提现状态
	for k, val := range uinfo.WithDraw.Cashdata {
		if val.Cnum == money {
			return k, &val
		}
	}
	return -1, nil
}

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 = 1000 //初始金币
	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
	udata.ContinueLoginDay = 1
	udata.SumLoginDay = 1
	udata.RandRedBagLeftTime = RANDGIFTLIMIT
	udata.FlyBoxNumTimes = FLYBOXNUMLIMIT
	udata.LeftTimingRewardTimes = TIMEINGREWARDLIMIT
	udata.LeftOfflineTimes = OFFLINETIMESLIMIT
	udata.EmptyBoxLeftTime = EMPTYBOXLIMIT
	/*randint := rand.Intn(100)
	floatval := float32(randint) / 100
	udata.TodayZhaocai = 180 + floatval*/

	udata.SumRandRedBagTimes = 0
	udata.StoreRandRedBag = 0
	udata.Gameid = data.Gameid
	udata.Channel = data.Channel
	//test
	udata.FlopCardLefCnt = 100
	udata.NickName = "著名的沙雕玩家"
	udata.Head = "https://wx.qlogo.cn/mmopen/vi_32/Q0j4TwGTfTIjPolxbUHLkrrfTBDl9Nj6KDicqHibXnMfM6L9cY2IT95T2hmv5RWXLrmGas7ms1A1H0jg8kDQFcGw/132"

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

		d1.Cat = 0
		//d1.Cat = 18
		if i < 2 {
			d1.Cat = 1
		}
		udata.PosInfo = append(udata.PosInfo, d1)

	}

	//初始化提现档位
	for _, val := range jsonconf.GetJsonConf().RMBConfig {
		var tmp WithDrawDesc
		tmp.Cid = val.Id
		tmp.Cnum = val.Rmb_num
		if val.Time == 1 {
			tmp.Isnew = 1
		} else {
			tmp.Isnew = 2
		}
		tmp.Limitlv = val.Cat_level
		tmp.LoginDayLimit = val.Login_day
		if val.Id == 1 {
			tmp.Preisfind = 1
		} else {
			tmp.Preisfind = 0
		}
		udata.WithDraw.Cashdata = append(udata.WithDraw.Cashdata, tmp)
	}

	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) bool {
	pos := getCatPutPos(u, catlv)
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return false
	}

	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
	return true
}

//计算购买后猫箱子的位置，将箱子放到对应位置 返回值表示位置 -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) float32 {

	rtpos := float32(0)

	//走随机合成逻辑
	sumrate := float32(0)
	var reallist []jsonconf.RedCatDesc
	for _, v := range jsonconf.GetJsonConf().RedCatConfig {
		sumrate += v.Rate
		if v.Rate > 0 {
			reallist = append(reallist, v)
		}
	}
	if len(reallist) == 0 {
		logger.Error("MergeRedBagCat nil")
		return 0
	}
	rand.Seed(time.Now().UnixNano())
	randnum := rand.Intn(100)
	index := -1
	tmprate := 0
	for k, v := range reallist {
		tmprate += int(v.Rate * 100 / sumrate)
		if tmprate >= randnum {
			if v.Id != 10 {
				index = k
				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 = 0
			} else {
				//红包猫
				index = k
				rtpos = v.Money
			}

			break
		}
	}

	if index == -1 {
		//没有找到 直接获得第一个
		uinfo.PosInfo[pos].Cat = reallist[0].Id + REDCATIDEXTRA
		uinfo.PosInfo[pos].RedPacket = reallist[0].Money
		uinfo.PosInfo[pos].Position = pos
		rtpos = reallist[0].Money
	}

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

func (uinfo *UserData) CheckBuyCatSHop() {
	//检查可购买的猫是否会增加
	//需要扩充一下商店
	curshoplv := len(uinfo.BuyCatInfo)
	//获取最高猫的配置
	highcfg := jsonconf.GetCatConfig(uinfo.Highestlv)
	if highcfg == nil {
		logger.Error("CheckBuyCatSHop err nil")
		return
	}

	if highcfg.Level_buy > curshoplv {
		offset := highcfg.Level_buy - curshoplv
		for i := 0; i < offset; i++ {
			var info BuyCatInfoData
			info.Buytime = 0
			cafcfg := jsonconf.GetCatConfig(curshoplv + i + 1)
			if cafcfg != nil {
				info.CurPrice, _ = strconv.ParseInt(cafcfg.Price, 10, 64)
			}
			info.IsMaxBuytime = 0
			uinfo.BuyCatInfo = append(uinfo.BuyCatInfo, info)
		}
	}
	/*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 && v.Cat < BOXGIFTEXTRA {
			//红包猫  需要判断是否产金币
			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, int) {
	higestlv := 0
	for _, val := range u.PosInfo {
		if val.Cat < BOXGIFTEXTRA && 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 "", 0
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcHigestCatName Unmarshal redis failed ")
		return "", 0
	}
	for _, val := range wdata.Info {
		reallv := val.Warelv
		if higestlv < reallv {
			higestlv = reallv
		}
	}

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

}

//获取红包猫列表
func (u *UserData) GetRedCatIdList() []LimitListDesc {
	var rtsl []LimitListDesc
	nowtime := int(time.Now().Unix())

	rtsl = append(rtsl, u.WaitFetchList...)

	for _, val := range u.PosInfo {
		if val.Cat > REDCATIDEXTRA && val.Cat < BOXGIFTEXTRA {
			//是红包猫并且是有时间的并且时间到了
			if val.RedPacket != 0 {

				if nowtime > val.StartTime+val.Time {
					var tmp LimitListDesc
					tmp.Cat = val.Cat
					tmp.Money = val.RedPacket
					rtsl = append(rtsl, tmp)
					//需要删除
					u.CleadPos(val.Position)

					//加入待领取列表
					u.WaitFetchList = append(u.WaitFetchList, tmp)
				}
			}

		}
	}

	/*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 {
		if val.RedPacket != 0 {
			if nowtime > val.StartTime+val.Time {
				var tmp LimitListDesc
				tmp.Cat = val.Warelv
				tmp.Money = val.RedPacket
				rtsl = append(rtsl, tmp)
			}
		}

	}

	//需要删除掉已经到期的猫
	for i := 0; i < len(wdata.Info); i++ {
		if nowtime > wdata.Info[i].StartTime+wdata.Info[i].Time {
			wdata.Info = append(wdata.Info[:i], wdata.Info[i+1:]...)
			i--
		}
	}*/

	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
}

func GetCashFromSDK(uuid int, goldnum int, gameid, channel, openid, nickname, headurl, ver string, checkcoin int) (int, error) {

	SERVERKEY := conf.GetCoinConf().Key

	if goldnum == 0 || uuid == 0 || gameid == "" || channel == "" || openid == "" || ver == "" {
		logger.Error("GetCashFromSDK param empty")
		return 0, errors.New("param empty")
	}
	var paramlist []string
	var params TixianDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	params.Headurl = headurl
	params.Money = goldnum
	params.Openid = openid
	params.Nickname = nickname
	params.Typ = 6
	params.Ver = ver
	params.Editcoin = 1
	params.Checkcoin = checkcoin
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	phead := "headurl=" + headurl
	pnickname := "nickname=" + nickname
	popenid := "openid=" + openid
	pmoney := "money=" + strconv.Itoa(goldnum)
	ptype := "typ=" + "6" //微信
	ped := "editcoin=1"
	pcheco := "checkcoin=" + strconv.Itoa(checkcoin)
	//pver := "ver=" + params.Ver
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)
	if headurl != "" {
		paramlist = append(paramlist, phead)
	}
	if nickname != "" {
		paramlist = append(paramlist, pnickname)
	}
	paramlist = append(paramlist, popenid)
	paramlist = append(paramlist, pmoney)
	paramlist = append(paramlist, ptype)
	paramlist = append(paramlist, ped)
	paramlist = append(paramlist, pcheco)
	//paramlist = append(paramlist, pver)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}
	res, err := DoHttpPost(bys, "api/server/tixian")
	logger.Info("GetCashFromSDK sumparam is:%v,sign is:%v", signsum, sign)
	logger.Info("GetCashFromSDK sumparam param=%v", string(bys))
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}

	logger.Info("GetCashFromSDK res=%v", res)

	var resp GetCashResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}

	if resp.Code != "0" {
		logger.Error("GetCashFromSDK failed=%v", resp.Msg)
		return 0, errors.New(resp.Msg)
	}

	//拉取一下新的金币值
	newnum, err := GetCoinFromSdk(uuid, gameid, channel)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}
	return newnum, nil
}

func GettotalParam(paramlist []string) string {
	//排序
	sort.Strings(paramlist)

	//拼接
	sumparam := ""
	for _, val := range paramlist {
		sumparam += val
	}

	return sumparam
}

func GetHashValue(signsum string) string {
	/*h := sha1.New()
	h.Write([]byte(signsum))
	bs := h.Sum(nil)
	sign := hex.EncodeToString(bs)*/
	ctx := md5.New()
	ctx.Write([]byte(signsum))
	return hex.EncodeToString(ctx.Sum(nil))
}

func DoHttpPost(bys []byte, apistr string) (string, error) {
	body := bytes.NewBuffer(bys)
	url1 := conf.GetCoinConf().Host + apistr //"api/server/addcoin"

	res, err := http.Post(url1, "application/json;charset=utf-8", body)
	if err != nil {
		logger.Error("DoHttpPost failed err=%v", err)
		return "", err
	}
	result, _ := ioutil.ReadAll(res.Body)
	defer res.Body.Close()

	return string(result), nil
}

func GetCoinFromSdk(uuid int, gameid string, channel string) (int, error) {

	SERVERKEY := conf.GetCoinConf().Key
	/*if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}*/

	var paramlist []string
	var params GetCoinDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign
	logger.Info("GetCoinFromSdk sumparam is:%v,sign is:", signsum, sign)

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}
	res, err := DoHttpPost(bys, "api/server/getcoin")
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}

	logger.Info("GetCoinFromSdk res=%v", res)

	var resp AddCoinResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}

	if resp.Code != "0" {
		logger.Error("GetCoinFromSdk failed=%v", resp.Msg)
		return 0, err
	}

	return resp.Data.Mycoin, nil
}

func GetCashList(uuid int, gameid string, channel string, start int, number int) (*[]WithDrawRecord, error) {
	SERVERKEY := conf.GetCoinConf().Key
	/*if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}*/

	var paramlist []string
	var params GetCashListDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	params.Start = start
	params.Number = number
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	pstart := "start=" + strconv.Itoa(start)
	pnumber := "number=" + strconv.Itoa(number)
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)
	if start != 0 {
		paramlist = append(paramlist, pstart)
	}

	paramlist = append(paramlist, pnumber)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY
	logger.Info("GetCashList sumparam=%v", signsum)

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCashList failed=%v", err)
		return nil, err
	}
	res, err := DoHttpPost(bys, "api/server/tixian/lst")
	if err != nil {
		logger.Error("GetCashList failed=%v", err)
		return nil, err
	}

	logger.Info("GetCashList res=%v", res)

	var resp GetCashListResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return nil, err
	}

	if resp.Code != "0" {
		logger.Error("GetCoinFromSdk failed=%v", resp.Msg)
		return nil, err
	}
	return &resp.Data, nil
}