package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"fmt"
	"math/rand"
	"net/http"
	"strconv"
	"sync"
	"time"
)

var (
	//m_userInfo *beegomap.BeeMap //make(map[int32]*UserData
	Maplock *sync.RWMutex
)

func init() {
	//m_userInfo = beegomap.NewBeeMap()
	Maplock = new(sync.RWMutex)

}

func MyInit() {
	pc := GetCurCaiCatList()
	if pc == nil {
		//初始化彩池
		NewCaiPiaoRound(0, 150, 150, 1)
	}
}

func SetHeader(w http.ResponseWriter) {
	w.Header().Set("Access-Control-Allow-Origin", "*") //允许访问所有域
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Access-Control-Allow-Headers", "Content-Type,uid,token")
	//	w.Header().Set("Access-Control-Allow-Headers", "Content-Type,token")

}

func HandlerSettlement(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp SettlementResp
	resp.Code = 0
	resp.Message = "success"
	var rdata SettlementReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerSettlement data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		//先判断一下待开奖列表
		iexis, err := redishandler.GetRedisClient().HExists(redis.CAIPIAOKAIJIANGWAIT_KEY, strconv.Itoa(rdata.Round))
		if err == nil && iexis {
			//开奖
			idx := -1
			list := GetWaitCaiCatList()
			logger.Info("HandlerSettlement list=%+v", list)
			for k, val := range list {
				if val.CurRound == rdata.Round {
					idx = k
					break
				}
			}

			if idx != -1 {
				list[idx].RewardNum, _ = strconv.Atoi(rdata.RewardNum)
				for _, vval := range list[idx].List {
					uinfo1, err := GetUserInfo(strconv.Itoa(vval.UserId))
					if err != nil || uinfo1 == nil {
						continue
					}
					var tmp UserCaiPiaoHistory
					tmp.RewardNum, _ = strconv.Atoi(rdata.RewardNum)
					cid := strconv.Itoa(list[idx].CurRound) + strconv.Itoa(vval.ChooseNum)
					tmp.CatId, _ = strconv.Atoi(cid)
					tmp.Round = rdata.Round
					tmp.Cnum = vval.ChooseNum
					uinfo1.CaiPiaoInfo = append(uinfo1.CaiPiaoInfo, tmp)

					if vval.ChooseNum == tmp.RewardNum {
						list[idx].RewardUser = vval.UserId

						//给这个玩家发奖
						cfg := jsonconf.GetRedCatConfig(48)
						if cfg != nil {

							uinfo1.AddRedPackect(cfg.Money, 100)
						}

					}

					SaveUserInfo(uinfo1, strconv.Itoa(vval.UserId))
				}

				//需要把这一条记录删除
				redishandler.GetRedisClient().HDel(redis.CAIPIAOKAIJIANGWAIT_KEY, strconv.Itoa(rdata.Round))

				var tmp AlreadyDuboCatList
				tmp.CurRound = rdata.Round
				tmp.RewardNum, _ = strconv.Atoi(rdata.RewardNum)
				tmp.List = append(tmp.List, list[idx].List...)
				tmp.RewardUser = list[idx].RewardUser
				tmp.TimeStr = int(time.Now().Unix())
				savestr, err := json.Marshal(&tmp)
				if err == nil {
					redishandler.GetRedisClient().HSet(redis.CAIPIAOKAIJIANGHISTORY_KEY, strconv.Itoa(tmp.CurRound), string(savestr))
				}
			}
		} else {
			//从当前未满彩池查看
			curr := GetCurCaiCatList()
			rewarduser := 0
			if curr.CurRound == rdata.Round {
				for _, vval := range curr.List {
					uinfo2, err := GetUserInfo(strconv.Itoa(vval.UserId))

					if err != nil || uinfo2 == nil {
						continue
					}
					logger.Info("HandlerSettlement111111111111 uinfo.CaiPiaoInfo=%+v", uinfo2.CaiPiaoInfo)
					var tmp UserCaiPiaoHistory
					tmp.RewardNum, _ = strconv.Atoi(rdata.RewardNum)
					cid := strconv.Itoa(rdata.Round) + strconv.Itoa(vval.ChooseNum)
					tmp.CatId, _ = strconv.Atoi(cid)
					tmp.Round = rdata.Round
					tmp.Cnum = vval.ChooseNum
					uinfo2.CaiPiaoInfo = append(uinfo2.CaiPiaoInfo, tmp)

					if vval.ChooseNum == tmp.RewardNum {
						rewarduser = vval.UserId

						//给这个玩家发奖
						cfg := jsonconf.GetRedCatConfig(48)
						if cfg != nil {

							uinfo2.AddRedPackect(cfg.Money, 100)
						}

					}

					logger.Info("HandlerSettlement2222222222222222222 uinfo.CaiPiaoInfo=%+v", uinfo2.CaiPiaoInfo)
					err = SaveUserInfo(uinfo2, strconv.Itoa(vval.UserId))
					if err != nil {
						logger.Error("HandlerSettlement err=%v", err)
					}
				}

				var tmp AlreadyDuboCatList
				tmp.CurRound = rdata.Round
				tmp.RewardNum, _ = strconv.Atoi(rdata.RewardNum)
				tmp.List = append(tmp.List, curr.List...)
				tmp.RewardUser = rewarduser
				tmp.TimeStr = int(time.Now().Unix())
				savestr, err := json.Marshal(&tmp)
				if err == nil {
					redishandler.GetRedisClient().HSet(redis.CAIPIAOKAIJIANGHISTORY_KEY, strconv.Itoa(tmp.CurRound), string(savestr))
				}

				NewCaiPiaoRound(0, 150, 150, curr.CurRound+1)

			} else {
				logger.Error("HandlerSettlement paramfailed failed=%v", err)
				resp.Code = 1
				resp.Message = "参数不正确"
				break
			}
		}

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerSettlement getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		uinfo.DuboCat = uinfo.DuboCat[:0]

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerAddFlop(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp AddFlopResp
	resp.Code = 0
	resp.Message = "success"
	var rdata AddFlopReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerAddFlop data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerTestaddCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		uinfo.FlopCardLefCnt += rdata.Count
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerAddAdCount(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp AddAdCountResp
	resp.Code = 0
	resp.Message = "success"
	var rdata AddAdCountReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerChangeCoin data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerTestaddCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		uinfo.GetWatchAdsGoldTime += rdata.Count
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerChangeCoin(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ChangeCoinResp
	resp.Code = 0
	resp.Message = "success"
	var rdata ChangeCoinReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerChangeCoin data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerTestaddCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		addgold := rdata.Coin
		if rdata.Type == 0 {
			uinfo.Gold += addgold
			uinfo.GoldSum += addgold
		} else {
			uinfo.Gold -= addgold
		}

		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerTestaddCat(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp TestAddCatResp
	resp.Code = 0
	resp.Message = "success"
	var rdata TestAddCatReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerTestaddCat data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerTestaddCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if rdata.Position < 0 || rdata.Position > len(uinfo.PosInfo)-1 {
			logger.Error("HandlerTestaddCat Position failed=%v", err)
			resp.Code = 1
			resp.Message = "get Position failed"
			break
		}

		catid, _ := strconv.Atoi(rdata.CatId)
		if catid == 47 {
			//红包猫
			logger.Error("HandlerTestaddCat Position failed=%v", err)
			resp.Code = 1
			resp.Message = "参数错误"
			break
		} else if catid == 48 {
			//赌博猫
			uinfo.SetDuboCatPos(catid)
		} else {

			uinfo.PosInfo[rdata.Position].Cat = catid
			if catid > 36 {
				pos := rdata.Position
				cfg := jsonconf.GetRedCatConfig(catid)
				if cfg == nil {
					logger.Error("HandlerTestaddCat Position failed=%v", err)
					resp.Code = 1
					resp.Message = "参数错误"
					break
				}
				//需要处理红包
				if cfg.Id == 13 {
					uinfo.PosInfo[pos].Time = 10 * 60
					uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
				}
				if cfg.Id == 14 {
					uinfo.PosInfo[pos].Time = 15 * 60
					uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
				}
				if cfg.Id == 2 {
					uinfo.PosInfo[pos].Time = 24 * 60 * 60
					uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
				}
				uinfo.PosInfo[pos].RedPacket = cfg.Money
			}
		}

		uinfo.CalcGoldRate()
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

	//logger.Info("###HandlerLogin###rdata:%v", string(respstr))
}

func HandlerLogin(w http.ResponseWriter, data string, uuid int, token string) {
	SetHeader(w)
	var resp UserLoginResp
	resp.Code = 0
	resp.Message = "success"
	var rdata UserLoginReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerLogin data failed:%v,for:%v", err, data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		logger.Info("###HandlerLogin###rdata:%v", string(respstr))
		fmt.Fprint(w, string(respstr))
		return
	}

	//首先判断一下是否是首次登陆
	isexist, _ := redishandler.GetRedisClient().HExists(redis.USER_INFO__KEY, strconv.Itoa(rdata.UserId))
	if !isexist {
		//不存在
		//属于新登录的玩家数据
		InitUserInfo(&rdata, &resp, rdata.UserId)

	} else {
		uinfo, err := GetUserInfo(strconv.Itoa(rdata.UserId))

		if err != nil {
			logger.Info("GetUserInfo HandlerLogin data failed:%v,for:%v", err, data)
			resp.Message = "GetUserInfo failed"
			resp.Code = 2
			respstr, _ := json.Marshal(&resp)
			fmt.Fprint(w, string(respstr))
			return
		}
		uinfo.IsNew = 1
		resp.Data.Nickname = uinfo.NickName
		resp.Data.UserId = strconv.Itoa(rdata.UserId)
		resp.Data.AccessToken = token
		resp.Data.HeadImg = uinfo.Head
		resp.Data.LoginType = rdata.Lype
		uinfo.LastLoginTime = int(time.Now().Unix())

		err = SaveUserInfo(uinfo, strconv.Itoa(uuid))
		if err != nil {
			logger.Error("SaveUserInfo failed err=%v")
		}
		logger.Info("HandlerLogin uinfo=%+v", uinfo)
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

	logger.Info("###HandlerLogin###rdata:%v", string(respstr))
}

func HandlerDoBuyCat(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp DoBuyCatResp
	resp.Code = 0
	resp.Message = "success"
	var rdata DoBuyCatReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerDoBuyCat json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerDoBuyCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		catcfg := jsonconf.GetCatConfig(rdata.CatId)
		if catcfg == nil {
			logger.Error("HandlerDoBuyCat get cat cfg  failed=%v,lv=%v", err, rdata.CatId)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		if rdata.CatId < 1 || rdata.CatId > len(uinfo.BuyCatInfo) {
			logger.Error("HandlerDoBuyCat buy lv  failed=%v", err)
			resp.Code = 1
			resp.Message = "buy lv invalid"
			break
		}

		curprice := uinfo.BuyCatInfo[rdata.CatId-1].CurPrice
		if uinfo.Gold < curprice {
			logger.Error("HandlerDoBuyCat gold not enough  failed=%v", err)
			resp.Code = 1
			resp.Message = "金币不足"
			break
		}

		//需要找到一个位置
		catpos := getCatPutPos(uinfo, rdata.CatId)
		if catpos < 0 {
			logger.Error("HandlerDoBuyCat not enough place  failed=%v", err)
			resp.Code = 1
			resp.Message = "not enough place"
			break
		}
		//扣钱
		uinfo.Gold -= curprice

		//重新计算价格
		if uinfo.BuyCatInfo[rdata.CatId-1].IsMaxBuytime == 0 {
			uinfo.BuyCatInfo[rdata.CatId-1].CurPrice = int64(float64(uinfo.BuyCatInfo[rdata.CatId-1].CurPrice) * float64(catcfg.Ratio))
			uinfo.BuyCatInfo[rdata.CatId-1].Buytime++
			if uinfo.BuyCatInfo[rdata.CatId-1].Buytime >= catcfg.Increse_limit {
				uinfo.BuyCatInfo[rdata.CatId-1].IsMaxBuytime = 1
			}
		}

		//需要重新计算速率
		uinfo.CalcGoldRate()
		uinfo.IsNew = 1

		resp.Data.Price = strconv.FormatInt(uinfo.BuyCatInfo[rdata.CatId-1].CurPrice, 10)
		resp.Data.Position = catpos
		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())

		resp.Code = 0

		//保存
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break

	}
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerAddAd(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp AddAdResp
	resp.Code = 0
	resp.Message = "success"

	for {

		//暂时没处理

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetflyboxreward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetboxrewardResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetflyboxreward getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//获取剩余次数
		if uinfo.FlyBoxNumTimes < 1 {
			logger.Error("HandlerGetflyboxreward not times failed=%v", err)
			resp.Code = 1
			resp.Message = "已经没有剩余宝箱次数了"
			break
		}

		boxid := uinfo.GenerateFlyBoxID()
		cfg := jsonconf.GetBoxConfif(boxid)
		if cfg == nil {
			logger.Error("HandlerGetboxreward  getcfgfailed failed=%v", boxid)
			resp.Code = 1
			resp.Message = "getcfgfailed"
			break
		}
		if cfg.Ttype == 1 {
			//金币
			resp.Data.Getgold = int64(float32(uinfo.Goldrate) * cfg.Time)

			uinfo.Gold += resp.Data.Getgold
			uinfo.GoldSum += resp.Data.Getgold
		} else if cfg.Ttype == 2 {
			//红包
			resp.Data.Getredbag = cfg.Time
			uinfo.AddRedPackect(resp.Data.Getredbag, 100)
		}

		uinfo.FlyBoxNumTimes--
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGethorsemessage(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GethorsemessageResp
	resp.Code = 0
	resp.Message = "success"
	for {

		//首先随机类型
		idx := rand.Intn(2) + 1
		resp.Data.Horsetype = idx

		var value string
		if idx == 1 {
			//红包
			index := rand.Intn(len(REDBAGNUM))
			value = REDBAGNUM[index]
		} else {
			//猫
			index := rand.Intn(len(CATNAMELIST))
			value = CATNAMELIST[index]
		}

		resp.Data.Value = value
		resp.Data.Name = jsonconf.GetRandName()

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetcashrecord(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetcashrecordResp
	resp.Code = 0
	resp.Message = "success"
	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetcashrecord getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		list, err := GetCashList(uuid, uinfo.Gameid, uinfo.Channel, 0, 100)
		if err != nil {
			logger.Error("HandlerGetcashrecord failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = 1
			break
		}
		if list != nil {
			resp.Data.Withdata = append(resp.Data.Withdata, *list...)
		}

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetcash(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetcashResp
	resp.Code = 0
	resp.Message = "success"
	var rdata GetcashReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerGetcash json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetcash getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		index, info := uinfo.GetWithDrawData(rdata.Money)
		if index == -1 || info == nil {
			logger.Error("HandlerGetcash GetWithDrawData failed=%v", err)
			resp.Code = 1
			resp.Message = "get GetWithDrawData failed"
			break
		}

		if info.Cnum == 30 {
			//30的是连续登陆天数
			if uinfo.Highestlv < info.Limitlv || uinfo.ContinueLoginDay < info.LoginDayLimit {
				logger.Error("HandlerGetcash notfit failed=%v", err)
				resp.Code = 1
				resp.Message = "提现条件不满足"
				break
			}
		} else {
			_, highlv := uinfo.CalcHigestCatName()
			if highlv < info.Limitlv || uinfo.SumLoginDay < info.LoginDayLimit {
				logger.Error("HandlerGetcash notfit failed=%v", err)
				resp.Code = 1
				resp.Message = "提现条件不满足"
				break
			}
		}

		if info.Isnew == 0 {
			logger.Error("HandlerGetcash notfit failed=%v", err)
			resp.Code = 1
			resp.Message = "新人专享只能提取一次"
			break
		}

		if info.Preisfind == 0 {
			logger.Error("HandlerGetcash notfit failed=%v", err)
			resp.Code = 1
			resp.Message = "请先完成前一档提现"
			break
		}

		//判断一下前置条件的下一档
		if index == len(uinfo.WithDraw.Cashdata)-1 {
			//最后一档了不用处理
		} else {
			if index < len(uinfo.WithDraw.Cashdata)-1 {
				uinfo.WithDraw.Cashdata[index+1].Preisfind = 1
			}
		}

		checkcoin := 2 //不开启自动审核
		drawnum := int(rdata.Money * 100)
		gold, err := GetCashFromSDK(uuid, drawnum, uinfo.Gameid, uinfo.Channel, rdata.Openid, uinfo.NickName, uinfo.Head, rdata.Ver, checkcoin)
		if err != nil {
			logger.Error("HandlerGetcash GetCashFromSDK failed failed=%v", err)
			resp.Code = 1
			resp.Message = "从后台提现失败了"
			break

		}
		if info.Isnew == 1 {
			uinfo.WithDraw.Cashdata[index].Isnew = 0
		}

		resp.Data.Redbag = float32(gold) / 10000

		//保存
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break

	}
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerQuerygetcashinfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuerygetcashinfoResp
	resp.Code = 0
	resp.Message = "success"
	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetflyboxreward getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//返回
		resp.Data.Logindaycontinue = uinfo.ContinueLoginDay
		resp.Data.Logindaysum = uinfo.SumLoginDay
		resp.Data.Cashdata = append(resp.Data.Cashdata, uinfo.WithDraw.Cashdata...)

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerQueryemptybox(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryemptyboxResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerQueryemptybox getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		if uinfo.PosInfo[BOXGIFTPOS].Cat < BOXGIFTEXTRA {
			//没有存在合法的空格礼物
			logger.Error("HandlerQueryemptybox  empty failed=%v", err)
			resp.Code = 1
			resp.Message = "empty"
			break
		}

		boxid := uinfo.PosInfo[BOXGIFTPOS].Cat - BOXGIFTEXTRA
		cfg := jsonconf.GetGiftConfif(boxid)
		if cfg == nil {
			logger.Error("HandlerQueryemptybox  getcfgfailed failed=%v", err)
			resp.Code = 1
			resp.Message = "getcfgfailed"
			break
		}

		if cfg.Ttype == 1 {
			//金币
			resp.Data.Goldnum = int64(float32(uinfo.Goldrate) * cfg.Time)
		} else if cfg.Ttype == 2 {
			//红包
			resp.Data.Money = cfg.Time

		}

		//SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetboxreward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetboxrewardResp
	resp.Code = 0
	resp.Message = "success"
	var rdata GetboxrewardReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {
		if err != nil {
			logger.Error("HandlerGetboxreward json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetboxreward getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		if uinfo.PosInfo[BOXGIFTPOS].Cat < BOXGIFTEXTRA {
			//没有存在合法的空格礼物
			logger.Error("HandlerGetboxreward  empty failed=%v", err)
			resp.Code = 1
			resp.Message = "empty"
			break
		}

		//获取配置
		boxid := uinfo.PosInfo[BOXGIFTPOS].Cat - BOXGIFTEXTRA
		cfg := jsonconf.GetGiftConfif(boxid)
		if cfg == nil {
			logger.Error("HandlerGetboxreward  getcfgfailed failed=%v", err)
			resp.Code = 1
			resp.Message = "getcfgfailed"
			break
		}

		mult := int64(1)
		if rdata.Optype == 2 {
			mult = 2
		}

		if cfg.Ttype == 1 {
			//金币
			resp.Data.Getgold = int64(float32(uinfo.Goldrate) * cfg.Time)
			resp.Data.Getgold = resp.Data.Getgold * mult
			uinfo.Gold += resp.Data.Getgold
			uinfo.GoldSum += resp.Data.Getgold
		} else if cfg.Ttype == 2 {
			//红包
			resp.Data.Getredbag = cfg.Time * float32(mult)
			uinfo.AddRedPackect(resp.Data.Getredbag, 100)
		}

		uinfo.CleadPos(BOXGIFTPOS)

		uinfo.EmptyBoxLeftTime--

		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGeneratebox(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GenerateboxResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGeneratebox getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		if uinfo.PosInfo[BOXGIFTPOS].Cat != 0 {
			//位置被占用无法生成
			logger.Error("HandlerGeneratebox not empty failed=%v", err)
			resp.Code = 98
			resp.Message = "not empty"
			break
		}

		if uinfo.EmptyBoxLeftTime < 1 {
			logger.Error("HandlerGeneratebox no lefttimesy failed=%v", err)
			resp.Code = 99
			resp.Message = "当日剩余宝箱次数用尽"
			break
		}

		boxid := uinfo.GenerateBox()
		resp.Data.Boixid = boxid
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetrandredbag(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetrandredbagResp
	resp.Code = 0
	resp.Message = "success"
	var rdata GetrandredbagReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {

		if err != nil {
			logger.Error("HandlerGetrandredbag json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetrandredbag getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//直接领取
		if rdata.Optype == 1 {
			//直接领取
			if uinfo.RandRedBagLeftTime < 1 {
				//已经没有领取次数了
				logger.Error("HandlerGetrandredbag storenum not enough failed=%v", err)
				resp.Code = 1
				resp.Message = "storenum not enougd"
				break
			}

			addnum := uinfo.CalcRandRedBagNum()
			uinfo.AddRedPackect(addnum, 100)
			//addgold := int(addnum * 10000)
			resp.Data.Getnum = addnum

			uinfo.SumRandRedBagTimes++
			uinfo.RandRedBagLeftTime--
			uinfo.StoreRandRedBag = 0
		} else if rdata.Optype == 2 {
			//存储
			if uinfo.StoreRandRedBag >= 1 {
				//不能存更多
				logger.Error("HandlerGetrandredbag storenum failed=%v", err)
				resp.Code = 1
				resp.Message = "storenum failed"
				break
			}

			uinfo.StoreRandRedBag = 1
			resp.Data.Getnum = 0
		} else {
			//领取存储的红包
			if uinfo.StoreRandRedBag < 1 || uinfo.RandRedBagLeftTime < 1 {
				//没有可以领取的
				logger.Error("HandlerGetrandredbag storenum not enough failed=%v", err)
				resp.Code = 1
				resp.Message = "storenum not enougd"
				break
			}

			//加红包
			//计算一下零取值
			addnum := uinfo.CalcRandRedBagNum()
			uinfo.AddRedPackect(addnum, 100)
			//addgold := int(addnum * 10000)
			resp.Data.Getnum = addnum

			uinfo.StoreRandRedBag = 0
			uinfo.SumRandRedBagTimes++
			uinfo.RandRedBagLeftTime--

		}

		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerUpdateSocialInfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp UpdateSocialInfoResp
	resp.Code = 0
	resp.Message = "success"
	var rdata UpdateSocialInfoReq

	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Error("HandlerUpdateSocialInfo json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerUpdateSocialInfo getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		uinfo.NickName = rdata.Nickname
		uinfo.Head = rdata.HeadImg

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerUserInfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp UserInfoResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetUserData getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		resp.Data.UserId = uuid
		resp.Data.HeadImg = uinfo.Head
		resp.Data.Nickname = uinfo.NickName

		gold, err := GetCoinFromSdk(uinfo.UserId, uinfo.Gameid, uinfo.Channel)
		if err != nil {
			logger.Error("HandlerGetUserData getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		resp.Data.Cash = float32(gold) / 10000
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetUserData(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetUserDataResp
	resp.Code = 0
	resp.Message = "success"

	for {
		v, err := redishandler.GetRedisClient().HGet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid))
		if err != nil {
			logger.Info("CalcOfflineData get USER_LAST_CALC_TIME failed=%v", err)
			resp.Message = "redishandler failed"
			resp.Code = 1
			break
		}

		lasttime, _ := strconv.Atoi(v)
		nowtime := time.Now().Unix()
		if nowtime-int64(lasttime) < 0 {
			logger.Error("HandlerGetUserData nowtime=%v lasttime=%v", nowtime, lasttime)
			resp.Message = "request time small than zero"
			resp.Code = 1
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetUserData getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		//处理一下跨天了
		uinfo.HandlePassDay()

		if nowtime-int64(lasttime) > 5*60 {
			//算离线收益

			offsec := nowtime - int64(lasttime)
			if offsec > 2*3600 {
				offsec = 2 * 3600
			}

			uinfo.OfflineGold = offsec * uinfo.Goldrate
			resp.Data.Coin = strconv.FormatInt(uinfo.Gold, 10)
			resp.Data.Now = int(time.Now().Unix()) * 1000 //返回毫秒
			resp.Data.Output = "0"
			resp.Data.OfflineReward.OfflineTime = int(offsec)
			resp.Data.OfflineReward.Income = strconv.FormatInt(uinfo.OfflineGold, 10)
			resp.Data.OfflineReward.LeftTimes = uinfo.LeftOfflineTimes
		} else {
			//按费离线收益计算
			//先计算一下双倍时间是否过期了
			addgold := int64(0)
			offsec := nowtime - int64(lasttime)
			if uinfo.IsDouble == 1 {
				if nowtime > int64(uinfo.StartDoubleTime+150) {

					//加速过期了
					//计算部分三倍的
					if lasttime > uinfo.StartDoubleTime+150 {
						addgold = uinfo.Goldrate * offsec
					} else {
						noroffsec := nowtime - int64(uinfo.StartDoubleTime+150)
						accoffsec := offsec - noroffsec
						addgold = uinfo.Goldrate*accoffsec*3 + noroffsec*uinfo.Goldrate
					}
					uinfo.IsDouble = 0
					uinfo.StartDoubleTime = 0

				} else {
					//还在加速期
					addgold = uinfo.Goldrate * offsec * 3
				}

			} else {
				addgold = uinfo.Goldrate * offsec
			}

			//resp.Data.TimingReward = true
			resp.Data.Now = int(time.Now().Unix()) * 1000

			uinfo.Gold += addgold
			uinfo.GoldSum += addgold
			uinfo.AddToRank()

			output := uinfo.Goldrate

			if uinfo.IsDouble == 1 {
				output = uinfo.Goldrate * 3
			}
			resp.Data.Output = strconv.FormatInt(output, 10)
			resp.Data.Coin = strconv.FormatInt(uinfo.Gold, 10)
			//			logger.Info("HandlerGetUserData addgold=%v IsDouble=%v resp=%+v", addgold, uinfo.IsDouble, resp)

			SaveUserInfo(uinfo, strconv.Itoa(uuid))
		}

		//计算一下整点奖励是否可以领取
		resp.Data.TimingReward = false
		nowt := time.Now()
		nowmin := nowt.Minute() + nowt.Hour()*60
		//	logger.Info("HandlerGetUserData nowmin=%v LastTimingRewardHour=%v", nowmin, uinfo.LastTimingRewardHour)
		if nowmin/30 > uinfo.LastTimingRewardHour {
			resp.Data.TimingReward = true
		}

		resp.Data.TimingRewardNum = uinfo.Goldrate * ZHENGHOURMULT

		//resp.Data.TimingReward = false
		resp.Data.TimingRewardTimes = uinfo.LeftTimingRewardTimes

		//保存此次计算时间
		nowtimestr := strconv.FormatInt(nowtime, 10)
		redishandler.GetRedisClient().HSet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid), nowtimestr)
		//logger.Info("HandlerGetUserData save USER_LAST_CALC_TIME time=%v", nowtimestr)

		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetOfflineReward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetOfflineRewardResp
	resp.Code = 0
	resp.Message = "success"
	var rdata GetOfflineRewardReq

	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerGetOfflineReward json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetUserData getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if uinfo.LeftOfflineTimes < 1 {
			logger.Error("HandlerGetUserData LeftOfflineTimes failed=%v", err)
			resp.Code = 1
			resp.Message = "离线奖励剩余领取次数为0"
			break
		}

		addgold := uinfo.OfflineGold

		if rdata.Optype == 2 {
			addgold *= 2

		}
		uinfo.Gold += addgold
		uinfo.GoldSum += addgold
		uinfo.AddToRank()

		//此处todo 记录离线领取的次数
		uinfo.LeftOfflineTimes--

		//领取过后将离线金币清零
		uinfo.OfflineGold = 0

		//保存
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerQueryPlayerRank(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryPlayerRankResp
	resp.Code = 0
	resp.Message = "success"
	for {
		//取100名
		vv, err := redishandler.GetRedisClient().ZRevRangewithIndex(redis.USER_GOLD_RANK, 0, 99)
		if err == nil {
			rank := 0
			for _, v := range vv {
				rank++

				rinfobyte, _ := v.([]byte)
				logger.Info("HandlerQueryPlayerRank ,v=%v", string(rinfobyte))
				ruid, _ := strconv.Atoi(string(rinfobyte))
				rindo, err := GetUserInfo(string(rinfobyte))
				if err == nil && rindo != nil {
					var tmp RankInfoDesc
					tmp.UserId = ruid
					tmp.Income = rindo.GoldSum
					tmp.Nickname = rindo.NickName
					tmp.Headurl = rindo.Head
					tmp.Rank = rank
					tmp.CatName, tmp.Level = rindo.CalcHigestCatName()
					//tmp.Level = len(rindo.BuyCatInfo)
					resp.Data = append(resp.Data, tmp)
				}
			}
		} else {
			logger.Error("HandlerUpdateUserInfo redisfailed ")
			resp.Code = 1
			resp.Message = "redisfailed"
			break
		}
		resp.Code = 0
		break
	}

	//回包
	logger.Info("HandlerQueryPlayerRank resp=%+v", resp)
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerGetMainPageInfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetMainPageInfoResp
	resp.Code = 0
	resp.Message = "success"
	for {

		v, err := redishandler.GetRedisClient().HGet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid))
		if err != nil {
			logger.Info("HandlerGetMainPageInfo get USER_LAST_CALC_TIME failed=%v", err)
			resp.Message = "redishandler failed"
			resp.Code = 1
			break
		}

		lasttime, _ := strconv.Atoi(v)
		nowtime := time.Now().Unix()
		if nowtime-int64(lasttime) < 0 {
			logger.Error("HandlerGetUserData nowtime=%v lasttime=%v", nowtime, lasttime)
			resp.Message = "request time small than zero"
			resp.Code = 1
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerGetMainPageInfo getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if nowtime-int64(lasttime) > 5*60 {
			//在同步资源的时候计算

		} else {
			//按费离线收益计算
			//先计算一下双倍时间是否过期了
			addgold := int64(0)
			offsec := nowtime - int64(lasttime)
			if uinfo.IsDouble == 1 {
				if nowtime > int64(uinfo.StartDoubleTime+150) {

					//加速过期了
					//计算部分三倍的
					if lasttime > uinfo.StartDoubleTime+150 {
						addgold = uinfo.Goldrate * offsec
					} else {
						noroffsec := nowtime - int64(uinfo.StartDoubleTime+150)
						accoffsec := offsec - noroffsec
						addgold = uinfo.Goldrate*accoffsec*3 + noroffsec*uinfo.Goldrate
					}
					uinfo.IsDouble = 0
					uinfo.StartDoubleTime = 0

				} else {
					//还在加速期
					addgold = uinfo.Goldrate * offsec * 3
				}

			} else {
				addgold = uinfo.Goldrate * offsec
			}

			uinfo.Gold += addgold
			uinfo.GoldSum += addgold
			uinfo.AddToRank()
			//	logger.Info("HandlerGetMainPageInfo addgold=%v,resp=%+v", addgold, resp)

			SaveUserInfo(uinfo, strconv.Itoa(uuid))
		}

		//保存此次计算时间
		nowtimestr := strconv.FormatInt(nowtime, 10)
		redishandler.GetRedisClient().HSet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid), nowtimestr)
		//logger.Info("HandlerGetMainPageInfo save USER_LAST_CALC_TIME time=%v", nowtimestr)

		redlist := uinfo.GetRedCatIdList()
		resp.Data.LimitCatList = append(resp.Data.LimitCatList, redlist...)
		uinfo.CalcGoldRate()
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Data.CatList = append(resp.Data.CatList, uinfo.PosInfo...)
		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Data.AdRate.Multiple = 1
		if uinfo.IsDouble == 1 {
			resp.Data.AdRate.Multiple = 3
			resp.Data.AdRate.EndTime = uinfo.StartDoubleTime + 150
			accrate := uinfo.Goldrate * 3
			resp.Data.Coin.IcomeRate = strconv.FormatInt(accrate, 10)
		}

		_, resp.Data.Level = uinfo.CalcHigestCatName() //len(uinfo.BuyCatInfo)
		resp.Data.TotalCashReward = G_randVal

		resp.Data.Guide = true
		if uinfo.IsNew == 0 {
			resp.Data.Guide = false
		}
		resp.Data.Redbagnum = uinfo.StoreRandRedBag
		resp.Data.Flyboxnum = uinfo.FlyBoxNumTimes
		resp.Data.Leftredbagnum = uinfo.RandRedBagLeftTime
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerDoFlop(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp DoFlopResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerDoFlop getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//判断一下翻拍次数是否足够
		if uinfo.FlopCardLefCnt <= 0 {
			logger.Error("HandlerDoFlop flopcnt failed=%v", err)
			resp.Code = 1
			resp.Message = "翻拍次数不足"
			break
		}

		//判断下是否有位置
		if !uinfo.HasEmptyPos() {
			logger.Error("HandlerDoFlop flopcnt failed=%v", err)
			resp.Code = 1
			resp.Message = "请尽快合成或回收猫咪为分红猫腾出位置"
			break
		}

		uinfo.DoFlopCardd(&resp)

		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerQueryFlop(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryFlopResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerQueryFlop getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		resp.Data.LeftTimes = uinfo.FlopCardLefCnt
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerDrawTable(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp DrawTableResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerDrawTable getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//抽奖券数量是否足够
		if uinfo.DrawTicket <= 0 {
			logger.Error("HandlerDrawTable ticketnotenough failed=%v", err)
			resp.Code = 1
			resp.Message = "ticketnotenough"
			break
		}

		//根据抽奖次数
		tid := uinfo.DrawTable()
		tablecfg := jsonconf.GetTurnTableCfg(tid)
		if tablecfg == nil {
			logger.Error("HandlerDrawTable tid failed=%v", tid)
			resp.Code = 1
			resp.Message = "tidnotright"
			break
		}

		//加金币 此处现金概率为零不做处理

		addgold := int64(tablecfg.Parameter) * uinfo.Goldrate
		if uinfo.DratMult != 1 {
			addgold = addgold * int64(uinfo.DratMult)
		}

		uinfo.DrawTicket--
		uinfo.DratMult = 1
		uinfo.DrawTableCount++
		if uinfo.DrawTableCount > 5 {
			uinfo.DrawTableCount = 1
		}

		uinfo.Gold += addgold
		uinfo.GoldSum += addgold

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Data.Coin = strconv.FormatInt(addgold, 10)
		resp.Data.RewardId = tid
		resp.Code = 0
		break
	}

	//回包
	logger.Info("HandlerDrawTable resp=%+v", resp)
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerMultiple(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp MultipleResp
	resp.Code = 0
	resp.Message = "success"
	var rdata MultipleReq

	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerMultiple json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "json failed"
			break
		}

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerMultiple getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		cfg := jsonconf.GetTurnTableCfg(rdata.RewardId)
		if cfg == nil {
			logger.Error("HandlerMultiple getcfgfailed failed=%v", rdata.RewardId)
			resp.Code = 1
			resp.Message = "getcfgfailed failed"
			break
		}

		uinfo.DratMult = cfg.Parameter
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerAddTicket(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp AddTicketResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerQueryTurntable getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if uinfo.DrawTicketTimes == 0 {
			logger.Error("HandlerQueryTurntable DoubleLeftTimes failed=%v", err)
			resp.Code = 1
			resp.Message = "DoubleLeftTimes not enough"
			break
		}

		uinfo.DrawTicketTimes--
		uinfo.DrawTicket += 5
		if uinfo.DrawTicket > DRAWTICKETNUMLIMIT {
			uinfo.DrawTicket = DRAWTICKETNUMLIMIT
		}

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerQueryTurntable(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryTurntableResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerQueryTurntable getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		resp.Data.TicketCount = uinfo.DrawTicket
		resp.Data.LeftTime = uinfo.DrawTicketTimes
		resp.Data.LimitTicket = DRAWTICKETNUMLIMIT

		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerLimitCatList(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp LimitCatListResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerRecvRedCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		poslist := uinfo.GetRedCatIdList()
		logger.Info("HandlerLimitCatList poslist=%+v", poslist)
		/*nowtime := int(time.Now().Unix())
		for _, pos := range poslist {
			if pos >= 0 && pos < len(uinfo.PosInfo) {
				//如果可领取了再加入列表
				if nowtime > uinfo.PosInfo[pos].StartTime+uinfo.PosInfo[pos].Time {
					if uinfo.PosInfo[pos].RedPacket > 0 {
						var tmp LimitCatListData
						tmp.CatId = uinfo.PosInfo[pos].Cat
						tmp.Status = 0
						tmp.Cash = uinfo.PosInfo[pos].RedPacket
						tmp.Date = time.Now().Format("2006-01-02T 15:04:05")
						resp.Data = append(resp.Data, tmp)
					}

				} else {
					logger.Info("HandlerLimitCatList nowtime=%v,endtime=%v", nowtime, uinfo.PosInfo[pos].StartTime+uinfo.PosInfo[pos].Time)
				}

			}
		}*/
		for _, v := range poslist {
			var tmp LimitCatListData
			tmp.CatId = v.Cat
			tmp.Status = 0
			tmp.Cash = v.Money
			tmp.Date = time.Now().Format("2006-01-02T 15:04:05")
			resp.Data = append(resp.Data, tmp)
		}

		resp.Code = 0
		break
	}

	//回包
	logger.Info("HandlerLimitCatList resp=%+v", resp)
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerRecvRedCat(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp RecvRedCatResp
	resp.Code = 0
	resp.Message = "success"
	var rdata RecvRedCatReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {
		if err != nil {
			logger.Info("json decode HandlerRecvRedCat data failed:%v", err, " for:%v", data)
			resp.Message = "json unmarshal failed"
			resp.Code = 1
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerRecvRedCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//从待领取列表删除
		idx := -1
		for i := 0; i < len(uinfo.WaitFetchList); i++ {
			if uinfo.WaitFetchList[i].Cat == rdata.RedCatId {
				idx = i
				break
			}
		}

		if idx == -1 {
			logger.Error("HandlerRecvRedCat idx failed=%v", rdata)
			resp.Code = 1
			resp.Message = "没有可领取的分红猫"
			break
		}

		//先判断位置
		/*cpos := uinfo.GetCatPos(rdata.RedCatId)
		if cpos == -1 {
			logger.Error("HandlerRecvRedCat nothave cat failed=%v", rdata.RedCatId)
			resp.Code = 1
			resp.Message = "nothave cat failed"
			break
		}

		//判读下计时的时间是否结束
		nowtime := int(time.Now().Unix())
		v := uinfo.PosInfo[cpos]
		if v.Time != 0 {
			if nowtime < v.StartTime+v.Time {
				//时间还未结束无法领取
				logger.Error("HandlerRecvRedCat timenotenough failed=%v", rdata.RedCatId)
				resp.Code = 1
				resp.Message = "timenotenough failed"
				break
			}
		}
		*/
		//领取红包
		cfg := jsonconf.GetRedCatConfig(rdata.RedCatId)
		if cfg == nil {
			logger.Error("GetRedCatConfig failede")
			resp.Code = 1
			resp.Message = "获取配置失败"
			break
		}
		addredpack := cfg.Money
		if rdata.Rtype == 1 {
			addredpack = addredpack * 2
		}

		_, err = uinfo.AddRedPackect(addredpack, 100)
		if err != nil {
			logger.Error("AddRedPackect failed")
			resp.Code = 1
			resp.Message = "获取红包失败"
			break
		}

		if idx != -1 {
			uinfo.WaitFetchList = append(uinfo.WaitFetchList[:idx], uinfo.WaitFetchList[idx+1:]...)
		}
		//删除待领取
		//uinfo.CleadPos(cpos)

		uinfo.CalcGoldRate()
		//uinfo.TodayZhaocai += addredpack

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Data.Num = addredpack
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerCompose(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ComposeResp
	resp.Code = 0
	resp.Message = "success"
	var rdata ComposeReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {
		if err != nil {
			logger.Info("json decode HandlerCompose data failed:%v", err, " for:%v", data)
			resp.Message = "json unmarshal failed"
			resp.Code = 1
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerCompose getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//先需要判断五个位置是否准确
		eastsum := 0
		westsum := 0
		southsum := 0
		northsum := 0
		middlesum := 0
		for _, val := range rdata.PositionList {
			if val < 0 || val >= len(uinfo.PosInfo) {
				logger.Error("HandlerCompose Position failed=%v", err)

				break
			}
			v := uinfo.PosInfo[val]
			if v.Cat == 3+REDCATIDEXTRA {
				eastsum++
			}
			if v.Cat == 4+REDCATIDEXTRA {
				westsum++
			}
			if v.Cat == 5+REDCATIDEXTRA {
				southsum++
			}
			if v.Cat == 6+REDCATIDEXTRA {
				northsum++
			}
			if v.Cat == 7+REDCATIDEXTRA {
				middlesum++
			}
		}
		if !(eastsum > 0 && westsum > 0 && northsum > 0 && southsum > 0 && middlesum > 0) {
			logger.Error("HandlerCompose notfivecat failed=%v", err)
			resp.Code = 1
			resp.Message = "notfivecat failed"
			break
		}

		//合成了五方猫
		//获取一天招财猫配置
		cfg := jsonconf.GetRedCatConfig(REDCATIDEXTRA + 2)
		if cfg == nil {
			logger.Error("HandlerCompose getcfg failed=%v", err)
			resp.Code = 1
			resp.Message = "getcfg failed"
			break
		}
		nowtime := int(time.Now().Unix())
		uinfo.SetCatPos(rdata.PositionList[0], 2+REDCATIDEXTRA, 24*3600, cfg.Money, nowtime)
		//清空其他位置的猫
		for k, v := range rdata.PositionList {
			if k > 0 {
				uinfo.CleadPos(v)
			}
		}

		//重新计算一下速度
		uinfo.CalcGoldRate()

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Data.CatList = append(resp.Data.CatList, uinfo.PosInfo...)
		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerRecovery(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp RecoveryResp
	resp.Code = 0
	resp.Message = "success"
	var rdata RecoveryReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {
		if err != nil {
			logger.Info("json decode HandlerRecovery data failed:%v", err, " for:%v", data)
			resp.Message = "服务器错误"
			resp.Code = 1
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerRecovery getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		if rdata.Position < 0 || rdata.Position >= len(uinfo.PosInfo) {
			logger.Error("HandlerRecovery Position failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		if uinfo.PosInfo[rdata.Position].Cat > 36 || uinfo.PosInfo[rdata.Position].Cat == 0 {
			//高级猫或者没有猫无法卖
			logger.Error("HandlerRecovery CatLV failed=%v", err)
			resp.Code = 1
			resp.Message = "37级猫咪无法回收哦！"
			break
		}

		catnum := uinfo.CalcMainCatNum()
		logger.Info("HandlerRecovery catnum=%v", catnum)
		if catnum <= 1 {
			logger.Error("HandlerRecovery CatLV failed=%v", err)
			resp.Code = 1
			resp.Message = "当前只有一只猫咪无法回收！"
			break
		}

		cfg := jsonconf.GetCatConfig(uinfo.PosInfo[rdata.Position].Cat)
		if cfg == nil {
			logger.Error("HandlerRecovery CatLVCFG failed=%v", uinfo.PosInfo[rdata.Position].Cat)
			resp.Code = 1
			resp.Message = "服务器错误d"
			break
		}
		uinfo.CleadPos(rdata.Position)

		//重新计算速度
		uinfo.CalcGoldRate()
		//加金币
		price, _ := strconv.ParseInt(cfg.Price, 10, 64)
		uinfo.Gold += price / 10
		uinfo.GoldSum += price / 10

		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Code = 0
		break
	}

	//回包
	logger.Info("HandlerRecovery resp=%v", resp)
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerRecvTimingReward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp RecvTimingRewardResp
	resp.Code = 0
	resp.Message = "success"
	var rdata RecvTimingRewardReq
	err := json.Unmarshal([]byte(data), &rdata)

	for {
		if err != nil {
			logger.Info("json decode HandlerRecvTimingReward data failed:%v", err, " for:%v", data)
			resp.Message = "json unmarshal failed"
			resp.Code = 1
			break
		}

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerRecvTimingReward getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//判断一下领取的时间点是否正确
		if uinfo.LeftTimingRewardTimes < 1 {
			logger.Error("HandlerRecvTimingReward LeftTimingRewardTimes failed=%v", err)
			resp.Code = 1
			resp.Message = "剩余领取次数为0"
			break
		}
		//nowt := time.Now()
		/*if nowt.Minute() < 50 && nowt.Minute() > 10 {
			logger.Error("HandlerRecvTimingReward time failed=%v", err)
			resp.Code = 1
			resp.Message = "time failed"
			break
		}*/

		//nowmin := nowt.Hour()*60+nowt.Minute()
		//if nowmin /30 <
		/*if nowt.Minute() >= 50 {
			//领取的是笑一个小时
			if nowt.Hour() < 23 {
				if uinfo.LastTimingRewardHour >= nowt.Hour()+1 {
					//已经领取过了 无法在零
					logger.Error("HandlerRecvTimingReward alreadyfetched failed=%v", err)
					resp.Code = 1
					resp.Message = "alreadyfetched failed"
					break
				}
				nowh = nowt.Hour()
			} else {
				if uinfo.LastTimingRewardHour == 0 {
					//已经领取过了 无法在零
					logger.Error("HandlerRecvTimingReward alreadyfetched failed=%v", err)
					resp.Code = 1
					resp.Message = "alreadyfetched failed"
					break
				}
				nowh = 0
			}

		}

		if nowt.Minute() <= 10 {
			//领取的是本时段的
			if uinfo.LastTimingRewardHour >= nowt.Hour() {
				//已经领取过了 无法在零
				logger.Error("HandlerRecvTimingReward alreadyfetched failed=%v", err)
				resp.Code = 1
				resp.Message = "alreadyfetched failed"
				break
			}
			nowh = nowt.Hour()
		}*/

		nowmin := time.Now().Hour()*60 + time.Now().Minute()
		addgold := uinfo.Goldrate * ZHENGHOURMULT

		if rdata.Optype == 2 {
			addgold = addgold * 2
		}
		uinfo.Gold += addgold
		uinfo.GoldSum += addgold
		uinfo.LastTimingRewardHour = nowmin / 30
		uinfo.LeftTimingRewardTimes--
		//uinfo.GetWatchAdsGoldTime--

		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Data.Reward = strconv.FormatInt(addgold, 10)
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerWatchAdsGetGold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp WatchAdsGetGoldResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerWatchAdsGetGold getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if uinfo.GetWatchAdsGoldTime <= 0 {
			//不够次数了
			logger.Error("HandlerWatchAdsGetGold not enoughtimes failed=%v", err)
			resp.Code = 101
			resp.Message = "金币不足（观看次数达到上限）"
			break
		}

		uinfo.GetWatchAdsGoldTime--
		addgold := uinfo.Goldrate * WATCHADSGOLDLRATE
		uinfo.Gold += addgold
		uinfo.GoldSum += addgold

		resp.Data.Reward = strconv.FormatInt(addgold, 10)
		resp.Data.LeftTimes = uinfo.GetWatchAdsGoldTime

		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		accrate := uinfo.Goldrate * 3
		resp.Data.Coin.IcomeRate = strconv.FormatInt(accrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerAcclecteGold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp AcclecteResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerAcclecteGold getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		if uinfo.IsDouble == 1 {
			//已经是加速状态
			logger.Error("HandlerAcclecteGold alreadyacclete failed=%v", err)
			resp.Code = 1
			resp.Message = "alreadyacclete"
			break
		}
		if uinfo.DoubleLeftTimes <= 0 {
			//不够次数了
			logger.Error("HandlerAcclecteGold not enoughtimes failed=%v", err)
			resp.Code = 1
			resp.Message = "enoughtimes"
			break
		}

		uinfo.IsDouble = 1
		uinfo.StartDoubleTime = int(time.Now().Unix())
		uinfo.DoubleLeftTimes--

		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Data.LeftTimes = uinfo.DoubleLeftTimes
		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		accrate := uinfo.Goldrate * 3
		resp.Data.Coin.IcomeRate = strconv.FormatInt(accrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Data.EndTime = uinfo.StartDoubleTime + DOUBLETIMELAST
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerLeftTimes(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp LeftRateTimesResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerLeftTimes getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		resp.Data.LeftTimes = uinfo.GetWatchAdsGoldTime
		resp.Data.LimitTimes = WATCHADSGOLDLIMIT

		resp.Code = 0
		break
	}
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerLeftRateTimes(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp LeftRateTimesResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerAcclecteGold getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		resp.Data.LeftTimes = uinfo.DoubleLeftTimes
		resp.Data.LimitTimes = ACCGOLDRATELIMIT

		resp.Code = 0
		break
	}
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerQueryBuyCat(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryBuyCatResp
	resp.Code = 0
	resp.Message = "success"

	for {

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerAcclecteGold getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		//需要返回到当前最高等级猫的所有数据
		for k, v := range uinfo.BuyCatInfo {
			var tmp BuyCatDesc
			tmp.CatId = k + 1
			tmp.Coin = strconv.FormatInt(v.CurPrice, 10)
			resp.Data = append(resp.Data, tmp)
		}
		_, highest := uinfo.CalcHigestCatName()
		offset := highest - len(uinfo.BuyCatInfo)
		if offset > 0 {
			for i := 0; i < offset; i++ {
				cfg := jsonconf.GetCatConfig(len(uinfo.BuyCatInfo) + i + 1)
				if cfg != nil {
					var tmp BuyCatDesc
					tmp.CatId = len(uinfo.BuyCatInfo) + i + 1
					tmp.Coin = cfg.Price
					resp.Data = append(resp.Data, tmp)
				}
			}
		}

		resp.Code = 0
		break
	}
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerExchangePos(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ExchangePosResp
	resp.Code = 0
	var rdata ExchangePosReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerExchangePos data failed:%v", err, " for:%v", data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		fmt.Fprint(w, string(respstr))
		return
	}

	for {
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerExchangePos getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		sumpos := len(uinfo.PosInfo) - 1
		//检查位置索引的合法性
		if rdata.From < 0 || rdata.To < 0 || rdata.From > sumpos || rdata.To > sumpos {
			logger.Error("HandlerExchangePos pos index not legal failed=%v", err)
			resp.Code = 1
			resp.Message = "pos index not legal"
			break
		}

		//下面判断是交换还是合成
		if uinfo.PosInfo[rdata.From].Cat == uinfo.PosInfo[rdata.To].Cat && uinfo.PosInfo[rdata.From].Cat < 37 {
			//相同 则合成
			//首先判断是否是顶级猫了
			if uinfo.PosInfo[rdata.From].Cat == 36 {
				//todo  走红包猫的逻辑
				idx := MergeRedBagCat(uinfo, rdata.To)
				uinfo.CleadPos(rdata.From)
				//DoAutoMergeRedCat(uinfo, uuid)
				//此处处理一下红包猫的自动合成逻辑
				if uinfo.Highestlv < 37 {
					//非红包猫
					uinfo.Highestlv = 37
					uinfo.CheckBuyCatSHop()
				}
				if idx > 0 {
					//红包猫
					uinfo.CleadPos(rdata.To)
					resp.Data.Reward = idx
					//加钱
					uinfo.AddRedPackect(idx, 100)
				}
				resp.Data.NewCat = uinfo.PosInfo[rdata.To].Cat

			} else {
				//
				uinfo.PosInfo[rdata.From].Cat = 0
				uinfo.PosInfo[rdata.To].Cat++
				if uinfo.PosInfo[rdata.To].Cat > uinfo.Highestlv {
					uinfo.Highestlv = uinfo.PosInfo[rdata.To].Cat
					resp.Data.NewCat = uinfo.PosInfo[rdata.To].Cat
					uinfo.CheckBuyCatSHop()

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

			}
		} else {
			//不相同 交换即可
			if (uinfo.PosInfo[rdata.From].Cat == 45 && uinfo.PosInfo[rdata.To].Cat == 46) || (uinfo.PosInfo[rdata.From].Cat == 46 && uinfo.PosInfo[rdata.To].Cat == 45) {
				//合成情侣猫
				addredpacket := uinfo.PosInfo[rdata.From].RedPacket + uinfo.PosInfo[rdata.To].RedPacket
				uinfo.PosInfo[rdata.From].Cat = 0
				uinfo.PosInfo[rdata.From].RedPacket = 0
				uinfo.PosInfo[rdata.To].Cat = 0
				uinfo.PosInfo[rdata.To].RedPacket = 0
				resp.Data.Reward = addredpacket
				uinfo.Redbag += addredpacket
				uinfo.AddRedPackect(addredpacket, 100)
				//todo  调用sdk接口
			} else {
				uinfo.PosInfo[rdata.From].Cat, uinfo.PosInfo[rdata.To].Cat = uinfo.PosInfo[rdata.To].Cat, uinfo.PosInfo[rdata.From].Cat
				uinfo.PosInfo[rdata.From].Time, uinfo.PosInfo[rdata.To].Time = uinfo.PosInfo[rdata.To].Time, uinfo.PosInfo[rdata.From].Time
				//uinfo.PosInfo[rdata.From].Position, uinfo.PosInfo[rdata.To].Position = uinfo.PosInfo[rdata.To].Position, uinfo.PosInfo[rdata.From].Position
				uinfo.PosInfo[rdata.From].RedPacket, uinfo.PosInfo[rdata.To].RedPacket = uinfo.PosInfo[rdata.To].RedPacket, uinfo.PosInfo[rdata.From].RedPacket
				uinfo.PosInfo[rdata.From].StartTime, uinfo.PosInfo[rdata.To].StartTime = uinfo.PosInfo[rdata.To].StartTime, uinfo.PosInfo[rdata.From].StartTime

			}
		}

		resp.Data.CatList = append(resp.Data.CatList, uinfo.PosInfo...)

		//重新计算速率
		uinfo.CalcGoldRate()
		uinfo.IsNew = 1

		//保存玩家数据
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))

}

func HandlerQueryWareHouse(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryWareHouseResp
	resp.Code = 0
	for {
		udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid))
		if err != nil {
			logger.Info("HandlerQueryWareHouse failed err=%v", err)
			resp.Code = 1
			resp.Message = "get redis failed"
			break
		}
		udata := new(UserWareHouseData)
		err = json.Unmarshal([]byte(udatastr), udata)
		if err != nil {
			logger.Error("HandlerQueryWareHouse Unmarshal redis failed ")
			resp.Code = 1
			resp.Message = "Unmarshal redis failed"
			break
		}

		for _, v := range udata.Info {
			catlv := v.Warelv
			if catlv > 0 {
				resp.Data.CatList = append(resp.Data.CatList, catlv)
			}

		}

		resp.Data.CatCapacity = WAREHOUSELIMIT

		resp.Code = 0
		break
	}

	logger.Info("HandlerQueryWareHouse resp=%+v", resp)
	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerRemoveCat(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ChooseNumResp

	resp.Code = 0
	resp.Message = "success"
	var rdata RemoveCatReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerRemoveCat data failed:%v", err, " for:%v", data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		fmt.Fprint(w, string(respstr))
		return
	}
	for {
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerRemoveCat getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		for i := 0; i < len(uinfo.CaiPiaoInfo); i++ {
			if uinfo.CaiPiaoInfo[i].CatId == rdata.CatId {
				uinfo.CaiPiaoInfo = append(uinfo.CaiPiaoInfo[:i], uinfo.CaiPiaoInfo[i+1:]...)
			}
		}

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerAutoChoose(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ChooseNumResp

	resp.Code = 0
	resp.Message = "success"

	for {

		//先校验一下有没有空的猫
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerExchangePos getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		catpos := -1
		for k, val := range uinfo.DuboCat {
			if val.ChooseNum == 0 {
				catpos = k
			}
		}
		if catpos == -1 {
			//当前没有可以选择号码的猫
			logger.Error("HandlerAutoChoose no cat failed=%v", err)
			resp.Code = 1
			resp.Message = "抱歉你没有猫可以选择号码"
			break
		}

		//首先找一个可以选取的号码
		cnum := 0
		vv, err := redishandler.GetRedisClient().HGetAllKeys(redis.CAIPIAOLEFTNUM_KEY)
		if err != nil {
			logger.Error("HandlerAutoChoose getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "HandlerAutoChoose failed"
			break
		}

		for _, val := range vv {
			//one := new(WaitDuboCatList)
			bytestr := val.([]byte)
			num, err := strconv.Atoi(string(bytestr))
			if err == nil {
				cnum = num
				break
			}
		}

		if cnum == 0 {
			//已经没有被选的号码了
			logger.Error("HandlerAutoChoose no num failed=%v", err)
			resp.Code = 1
			resp.Message = "no num"
			break
		}

		//加入当前彩池
		curpool := GetCurCaiCatList()
		if curpool == nil {
			//理论上会报错
			logger.Error("HandlerChooseNum pool empty!!")
			resp.Message = " pool empty"
			resp.Code = 1
			break
		} else {
			if catpos >= 0 && catpos < len(uinfo.DuboCat) {
				uinfo.DuboCat[catpos].ChooseNum = cnum
			}
			SaveUserInfo(uinfo, strconv.Itoa(uuid))
			//将该号码移除
			redishandler.GetRedisClient().HDel(redis.CAIPIAOLEFTNUM_KEY, strconv.Itoa(cnum))
			//添加
			var tmp UserCaiPiaoInfo
			tmp.ChooseNum = cnum
			cid := strconv.Itoa(curpool.CurRound) + strconv.Itoa(cnum)
			tmp.CatId, _ = strconv.Atoi(cid)
			tmp.UserId = uuid
			curpool.List = append(curpool.List, tmp)
			curpool.CurNum = len(curpool.List)
			logger.Info("SetCurCaiCatList")
			SetCurCaiCatList(curpool)
			//需要处理一下奖池是否满了
			fullnum := 149
			if curpool.FakeNum == 0 {
				fullnum++
			}

			if curpool.CurNum >= fullnum {
				//已经满了 重新生成新的奖池  将原先的加入到待开奖列表
				var waits WaitDuboCatList
				waits.CurRound = curpool.CurRound
				waits.RewardNum = 0
				waits.RewardUser = 0
				waits.FakeNum = curpool.FakeNum
				waits.List = append(waits.List, curpool.List...)

				savestr, _ := json.Marshal(&waits)
				err = redishandler.GetRedisClient().HSet(redis.CAIPIAOKAIJIANGWAIT_KEY, strconv.Itoa(waits.CurRound), string(savestr))
				if err != nil {
					logger.Error("HandlerChooseNum err=%v", err)
				}

				//生成新的彩池
				NewCaiPiaoRound(0, 150, 150, waits.CurRound+1)
			}

		}

		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerChooseNum(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp ChooseNumResp

	resp.Code = 0
	resp.Message = "success"
	var rdata ChooseNumReq
	err := json.Unmarshal([]byte(data), &rdata)
	if err != nil {
		logger.Info("json decode HandlerChooseNum data failed:%v", err, " for:%v", data)
		resp.Message = "json unmarshal failed"
		resp.Code = 1
		respstr, _ := json.Marshal(&resp)
		fmt.Fprint(w, string(respstr))
		return
	}

	for {

		//先判断一下当前号码是否已被选取
		isexist, err := redishandler.GetRedisClient().HExists(redis.CAIPIAOLEFTNUM_KEY, strconv.Itoa(rdata.Number))
		if err != nil {
			logger.Info("HandlerChooseNum failed:%v", err, " for:%v", data)
			resp.Message = "redis failed"
			resp.Code = 1
			break
		}

		if !isexist {
			//已经被选了
			logger.Info("HandlerChooseNum number alreadypicked failed:%v", err, " for:%v", data)
			resp.Message = " alreadypicked"
			resp.Code = 100
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerChooseNum getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		catpos := -1
		for k, val := range uinfo.DuboCat {
			if val.ChooseNum == 0 {
				catpos = k
			}
		}
		if catpos == -1 {
			//当前没有可以选择号码的猫
			logger.Error("HandlerChooseNum no cat failed=%v", err)
			resp.Code = 1
			resp.Message = "抱歉你没有猫可以选择号码"
			break
		}

		//加入当前彩池
		curpool := GetCurCaiCatList()
		if curpool == nil {
			//理论上会报错
			logger.Error("HandlerChooseNum pool empty!!")
			resp.Message = " pool empty"
			resp.Code = 1
			break
		} else {
			if catpos >= 0 && catpos < len(uinfo.DuboCat) {
				uinfo.DuboCat[catpos].ChooseNum = rdata.Number
			}
			//将该号码移除
			redishandler.GetRedisClient().HDel(redis.CAIPIAOLEFTNUM_KEY, strconv.Itoa(rdata.Number))
			//添加
			var tmp UserCaiPiaoInfo
			tmp.ChooseNum = rdata.Number
			cid := strconv.Itoa(curpool.CurRound) + strconv.Itoa(rdata.Number)
			tmp.CatId, _ = strconv.Atoi(cid)

			tmp.UserId = uuid
			curpool.List = append(curpool.List, tmp)
			curpool.CurNum = len(curpool.List)
			logger.Info("SetCurCaiCatList")
			SetCurCaiCatList(curpool)
			//需要处理一下奖池是否满了
			fullnum := 149
			if curpool.FakeNum == 0 {
				fullnum++
			}

			if curpool.CurNum >= fullnum {
				//已经满了 重新生成新的奖池  将原先的加入到待开奖列表
				var waits WaitDuboCatList
				waits.CurRound = curpool.CurRound
				waits.RewardNum = 0
				waits.RewardUser = 0
				waits.FakeNum = curpool.FakeNum
				waits.List = append(waits.List, curpool.List...)

				savestr, _ := json.Marshal(&waits)
				err = redishandler.GetRedisClient().HSet(redis.CAIPIAOKAIJIANGWAIT_KEY, strconv.Itoa(waits.CurRound), string(savestr))
				if err != nil {
					logger.Error("HandlerChooseNum err=%v", err)
				}

				//生成新的彩池
				NewCaiPiaoRound(0, 150, 150, waits.CurRound+1)
			}

		}

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerNumberList(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp NumberListResp

	resp.Code = 0
	resp.Message = "success"

	for {
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerNumberList getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}
		//先选取号码
		vv, err := redishandler.GetRedisClient().HGetAllKeys(redis.CAIPIAOLEFTNUM_KEY)
		if err != nil {
			logger.Error("HandlerNumberList getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "HandlerNumberList failed"
			break
		}

		var numlist []int
		for _, val := range vv {
			//one := new(WaitDuboCatList)
			bytestr := val.([]byte)
			num, err := strconv.Atoi(string(bytestr))
			if err == nil {
				numlist = append(numlist, num)
			}
			if len(numlist) >= 6 {
				break
			}
		}

		//查询当前奖池
		curpool := GetCurCaiCatList()
		if curpool != nil {
			resp.Data.Round = curpool.CurRound
		}

		for _, val := range numlist {
			var tmp NumberListDesc
			tmp.Number = val
			tmp.Choosed = false
			resp.Data.NumberList = append(resp.Data.NumberList, tmp)
		}

		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerQueryGambling(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryGamblingResp

	resp.Code = 0
	resp.Message = "success"

	for {
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerQueryGambling getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "get userinfo failed"
			break
		}

		for _, vv := range uinfo.CaiPiaoInfo {

			//先查询中奖者
			rewardnickname := ""
			rewardhead := ""
			ss, err := redishandler.GetRedisClient().HGet(redis.CAIPIAOKAIJIANGHISTORY_KEY, strconv.Itoa(vv.Round))
			if err != nil {
				logger.Error("HandlerQueryGambling err =%v", err)
				continue
			}
			var his AlreadyDuboCatList
			json.Unmarshal([]byte(ss), &his)
			if his.RewardUser != 0 {
				hisinfo, err := GetUserInfo(strconv.Itoa(his.RewardUser))
				logger.Info("HandlerQueryGambling his=%+v", his)
				if err == nil && hisinfo != nil {
					rewardhead = hisinfo.Head
					rewardnickname = hisinfo.NickName
				}
			} else {
				//todo
				rname, rdx := jsonconf.CalcWinner(vv.Round)

				rewardhead = "https://app-cdn.miso-lab.com/online/luckycat/defaultAvatar/" + strconv.Itoa(rdx) + ".jpg"
				rewardnickname = rname
			}

			logger.Info("HandlerQueryGambling rewardnickname=%v,rewardhead=%v", rewardnickname, rewardhead)
			var tmp QueryGamblingData
			tmp.CatId = vv.CatId
			tmp.Nickname = rewardnickname
			tmp.HeadImg = rewardhead
			tmp.MyNumber = vv.Cnum
			tmp.RewardNumber = vv.RewardNum
			tmp.Round = vv.Round
			tmp.Status = 1
			if vv.RewardNum == vv.Cnum {
				tmp.Status = 2
			}

			resp.Data = append(resp.Data, tmp)
		}

		//查询待开奖的
		waitlist := GetWaitCaiCatList()
		for _, vv := range waitlist {
			for _, val := range vv.List {
				if val.UserId == uuid {
					var tmp QueryGamblingData
					tmp.CatId = val.CatId
					tmp.Nickname = uinfo.NickName
					tmp.HeadImg = uinfo.Head
					tmp.MyNumber = val.ChooseNum
					tmp.RewardNumber = 0 //0表示未开奖
					tmp.Round = vv.CurRound
					tmp.Status = 0
					resp.Data = append(resp.Data, tmp)
				}
			}
		}

		//查询当前奖池
		curpool := GetCurCaiCatList()
		if curpool != nil {
			for _, val := range curpool.List {
				if val.UserId == uuid {
					var tmp QueryGamblingData
					tmp.CatId = val.CatId
					tmp.Nickname = uinfo.NickName
					tmp.HeadImg = uinfo.Head
					tmp.MyNumber = val.ChooseNum
					tmp.RewardNumber = 0 //0表示未开奖
					tmp.Round = curpool.CurRound
					tmp.Status = 0
					resp.Data = append(resp.Data, tmp)
				}
			}
		}
		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerPutCattoWareHouse(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp PutWareHouseResp

	resp.Code = 0
	var rdata PutWareHouseReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerPutCattoWareHouse json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid))
		if err != nil {
			logger.Info("HandlerPutCattoWareHouse failed err=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		udata := new(UserWareHouseData)
		err = json.Unmarshal([]byte(udatastr), udata)
		if err != nil {
			logger.Error("HandlerPutCattoWareHouse Unmarshal redis failed ")
			resp.Code = 1
			resp.Message = "Unmarshal redis failed"
			break
		}
		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerPutCattoWareHouse getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		if rdata.Position < 0 || rdata.Position >= len(uinfo.PosInfo) {
			logger.Error("HandlerPutCattoWareHouse posnotvalid failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		if uinfo.PosInfo[rdata.Position].StartTime != 0 {
			logger.Error("HandlerPutCattoWareHouse not right failed=%v", err)
			resp.Code = 1
			resp.Message = "分红猫无法放入仓库！"
			break
		}

		catnum := uinfo.CalcMainCatNum()
		if catnum <= 1 {
			logger.Error("HandlerPutCattoWareHouse not right failed=%v", err)
			resp.Code = 1
			resp.Message = "只有一只猫无法加入背包"
			break
		}

		//合成界面红包猫的等级采用id+37的形式
		rtval := uinfo.tryPutToWareHouse(udata, rdata.Position, uuid)
		if rtval == -1 {
			logger.Error("HandlerPutCattoWareHouse warehouse full failed=%v", err)
			resp.Code = 1
			resp.Message = "仓库已满，无法加入"
			break
		}

		uinfo.CleadPos(rdata.Position)
		uinfo.CalcGoldRate()
		SaveUserInfo(uinfo, strconv.Itoa(uuid))

		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		//accrate := uinfo.Goldrate * 3
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}

func HandlerTakeCatoutfromWareHouse(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp TakeWareHouseResp

	resp.Code = 0
	var rdata TakeWareHouseReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlerTakeCatoutfromWareHouse json unmarshal failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid))
		if err != nil {
			logger.Info("HandlerTakeCatoutfromWareHouse failed err=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		udata := new(UserWareHouseData)
		err = json.Unmarshal([]byte(udatastr), udata)
		if err != nil {
			logger.Error("HandlerTakeCatoutfromWareHouse Unmarshal redis failed ")
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}

		uinfo, err := GetUserInfo(strconv.Itoa(uuid))
		if err != nil || uinfo == nil {
			logger.Error("HandlerPutCattoWareHouse getuserinfo failed=%v", err)
			resp.Code = 1
			resp.Message = "服务器错误"
			break
		}
		cid, _ := strconv.Atoi(rdata.CatId)
		wpos := udata.GetWarePosById(cid)
		if wpos == -1 {
			logger.Error("HandlerTakeCatoutfromWareHouse wpos  failed=%v", err)
			resp.Code = 1
			resp.Message = "没有正确的猫"
			break
		}
		winfo := udata.Info[wpos]

		success := uinfo.SetRedCatPos(winfo.Warelv, winfo.Time, winfo.RedPacket, winfo.StartTime)
		if !success {
			logger.Error("HandlerTakeCatoutfromWareHouse wpos  failed=%v", err)
			resp.Code = 1
			resp.Message = "合成界面已满，请先整理置位"
			break
		}

		udata.Info[wpos].Warelv = 0
		udata.Info[wpos].StartTime = 0
		udata.Info[wpos].RedPacket = 0
		udata.Info[wpos].Time = 0

		wares, _ := json.Marshal(udata)
		redishandler.GetRedisClient().HSet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid), string(wares))

		uinfo.CalcGoldRate()

		SaveUserInfo(uinfo, strconv.Itoa(uuid))
		resp.Data.Coin.UserId = uuid
		resp.Data.Coin.Coin = strconv.FormatInt(uinfo.Gold, 10)
		resp.Data.Coin.IcomeRate = strconv.FormatInt(uinfo.Goldrate, 10)
		resp.Data.Coin.UpdateTime = int(time.Now().Unix())
		resp.Code = 0

		break
	}
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, string(respstr))
}