package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"fmt"
	"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, 200, 200, 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 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
		}

		uinfo.PosInfo[rdata.Position].Cat = rdata.CatId
		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
		}

		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())
		SaveUserInfo(uinfo, strconv.Itoa(uuid))
	}

	//回包
	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
		}

		maxlv := uinfo.Highestlv - 5
		if maxlv < 1 {
			//最小1j
			maxlv = 1
		}
		if rdata.CatId > maxlv || 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 = "gold not enough"
			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 = "get cat cfg failed"
			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()

		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 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 {
			//算离线收益
			resp.Data.TimingReward = false
			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())
			resp.Data.Output = "0"
			resp.Data.OfflineReward.OfflineTime = int(offsec)
			resp.Data.OfflineReward.Income = strconv.FormatInt(uinfo.OfflineGold, 10)
		} else {
			//按费离线收益计算
			//先计算一下双倍时间是否过期了
			addgold := int64(0)
			offsec := nowtime - int64(lasttime)
			if uinfo.IsDouble == 1 {
				if nowtime > int64(uinfo.IsDouble+150) {

					//加速过期了
					//计算部分三倍的
					if lasttime > uinfo.IsDouble+150 {
						addgold = uinfo.Goldrate * offsec
					} else {
						noroffsec := nowtime - int64(uinfo.IsDouble+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())

			uinfo.Gold = addgold
			uinfo.GoldSum += addgold
			uinfo.AddToRank()
			resp.Data.Output = strconv.FormatInt(uinfo.Goldrate, 10)
			resp.Data.Coin = strconv.FormatInt(uinfo.Gold, 10)
		}

		//保存此次计算时间
		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
		}

		addgold := uinfo.OfflineGold

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

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

		//此处todo 记录离线领取的次数

		//领取过后将离线金币清零
		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++
				//logger.Info("TestMyredis k=%v,v=%v", k, v)
				rinfobyte, _ := v.(string)
				ruid, _ := strconv.Atoi(rinfobyte)
				rindo, err := GetUserInfo(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 = rindo.CalcHigestCatName()
					resp.Data = append(resp.Data, tmp)
				}
			}
		} else {
			logger.Error("HandlerUpdateUserInfo redisfailed ")
			resp.Code = 1
			resp.Message = "redisfailed"
			break
		}
		resp.Code = 0
		break
	}

	//回包
	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.IsDouble+150) {

					//加速过期了
					//计算部分三倍的
					if lasttime > uinfo.IsDouble+150 {
						addgold = uinfo.Goldrate * offsec
					} else {
						noroffsec := nowtime - int64(uinfo.IsDouble+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()
		}

		//保存此次计算时间
		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...)

		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 = len(uinfo.BuyCatInfo)
		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
		}

		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

		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.DoubleLeftTimes == 0 {
			logger.Error("HandlerQueryTurntable DoubleLeftTimes failed=%v", err)
			resp.Code = 1
			resp.Message = "DoubleLeftTimes not enough"
			break
		}

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

		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.DoubleLeftTimes
		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.GetLimitCatList()

		for _, pos := range poslist {
			if pos > 0 && pos < len(uinfo.PosInfo) {
				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)
			}
		}

		resp.Code = 0
		break
	}

	//回包
	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
		}

		//先判断位置
		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
			}
		}

		//领取红包
		addredpack := v.RedPacket
		if rdata.Rtype == 1 {
			addredpack = addredpack * 2
		}

		uinfo.AddRedPackect(addredpack)
		uinfo.CleadPos(cpos)

		uinfo.CalcGoldRate()

		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 = "json unmarshal failed"
			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 = "get userinfo failed"
			break
		}

		if rdata.Position < 0 || rdata.Position >= len(uinfo.PosInfo) {
			logger.Error("HandlerRecovery Position failed=%v", err)
			resp.Code = 1
			resp.Message = "Position failed"
			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 = "CatLV failed"
			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 = "CatLVCFG failed"
			break
		}
		uinfo.CleadPos(rdata.Position)

		//重新计算速度
		uinfo.CalcGoldRate()
		//加金币
		price, _ := strconv.ParseInt(cfg.Price, 10, 64)
		uinfo.Gold += 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"

	for {

		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
		}

		//判断一下领取的时间点是否正确
		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
		}

		nowh := 0
		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()
		}

		addgold := uinfo.Goldrate * ZHENGHOURMULT
		uinfo.Gold += addgold
		uinfo.LastTimingRewardHour = nowh

		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 = 1
			resp.Message = "enoughtimes"
			break
		}

		uinfo.GetWatchAdsGoldTime--
		addgold := uinfo.Goldrate * WATCHADSGOLDLRATE
		uinfo.Gold += 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.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)
		}

		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 {
			//相同 则合成
			//首先判断是否是顶级猫了
			if uinfo.PosInfo[rdata.From].Cat == 36 {
				//todo  走红包猫的逻辑
				MergeRedBagCat(uinfo, rdata.From)
				DoAutoMergeRedCat(uinfo, uuid)
				//此处处理一下红包猫的自动合成逻辑
				if uinfo.Highestlv < 37 {
					//非红包猫
					uinfo.Highestlv = 37
					uinfo.CheckBuyCatSHop()
				}

			} 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 == 108 && uinfo.PosInfo[rdata.To].Cat == 109) || (uinfo.PosInfo[rdata.From].Cat == 109 && uinfo.PosInfo[rdata.To].Cat == 108) {
				//合成情侣猫
				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
				//todo  调用sdk接口
			} else {
				uinfo.PosInfo[rdata.From].Cat, uinfo.PosInfo[rdata.To].Cat = uinfo.PosInfo[rdata.To].Cat, uinfo.PosInfo[rdata.From].Cat
			}
		}
		//重新计算速率
		uinfo.CalcGoldRate()

		//保存玩家数据
		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"

	for {

		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
			tmp.CatId = 48
			tmp.UserId = uuid
			curpool.List = append(curpool.List, tmp)
			curpool.CurNum = len(curpool.List)
			logger.Info("SetCurCaiCatList")
			SetCurCaiCatList(curpool)
			//需要处理一下奖池是否满了
			fullnum := 199
			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, 200, 200, 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 {
			//将该号码移除
			redishandler.GetRedisClient().HDel(redis.CAIPIAOLEFTNUM_KEY, strconv.Itoa(rdata.Number))
			//添加
			var tmp UserCaiPiaoInfo
			tmp.ChooseNum = rdata.Number
			tmp.CatId = 48
			tmp.UserId = uuid
			curpool.List = append(curpool.List, tmp)
			curpool.CurNum = len(curpool.List)
			logger.Info("SetCurCaiCatList")
			SetCurCaiCatList(curpool)
			//需要处理一下奖池是否满了
			fullnum := 199
			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, 200, 200, waits.CurRound+1)
			}

		}

		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 {
			var tmp QueryGamblingData
			tmp.CatId = vv.CatId
			tmp.Nickname = uinfo.NickName
			tmp.HeadImg = uinfo.Head
			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 = "json failed"
			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 = "get redis failed"
			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 = "get userinfo failed"
			break
		}

		if rdata.Position < 0 || rdata.Position >= len(uinfo.PosInfo) {
			logger.Error("HandlerPutCattoWareHouse posnotvalid failed=%v", err)
			resp.Code = 1
			resp.Message = "posnotvalid"
			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 = "warehouse full"
			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 = "json failed"
			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 = "get redis failed"
			break
		}
		udata := new(UserWareHouseData)
		err = json.Unmarshal([]byte(udatastr), udata)
		if err != nil {
			logger.Error("HandlerTakeCatoutfromWareHouse 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 = "get userinfo failed"
			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 = "wpos"
			break
		}
		winfo := udata.Info[wpos]

		uinfo.SetRedCatPos(winfo.Warelv, winfo.Time, winfo.RedPacket, winfo.StartTime)

		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))
}