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

			}

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

			uinfo.Gold = addgold
			uinfo.GoldSum += addgold
			uinfo.AddToRank()
			resp.Data.Output = strconv.FormatInt(addgold, 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 {
		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
		}
		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.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 == 103 {
				eastsum++
			}
			if v.Cat == 104 {
				westsum++
			}
			if v.Cat == 105 {
				southsum++
			}
			if v.Cat == 106 {
				northsum++
			}
			if v.Cat == 107 {
				middlesum++
			}
		}
		if !(eastsum > 0 && westsum > 0 && northsum > 0 && southsum > 0 && middlesum > 0) {
			logger.Error("HandlerCompose notfivecat failed=%v", err)
			resp.Code = 1
			resp.Message = "notfivecat failed"
			break
		}

		//合成了五方猫
		//获取一天招财猫配置
		cfg := jsonconf.GetRedCatConfig(100 + 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+100, 24*3600, cfg.Money, nowtime)
		//清空其他位置的猫
		for k, v := range rdata.PositionList {
			if k > 0 {
				uinfo.CleadPos(v)
			}
		}

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

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

}