package logic

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

var llock sync.Mutex

func HandlerQueryguaninfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryguaninfoResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		uinfo.HandlePassDay(uuid, rdata.Channel)

		//获取存钱罐等级配置
		mcfg := jsonconf.GetMoneyBoxCfg(uinfo.Lv)
		if mcfg == nil {
			logger.Error("GetMoneyBoxCfg failed uinfo.Lv=%v", uinfo.Lv)
			logger.Error("GetMoneyBoxCfg failed cfg=%v", jsonconf.GetJsonConf().MoneyBoxConfig)
			resp.Message = "存钱罐金币不足"
			resp.Code = ERROR_GETCONFIG_FAILED
			break
		}

		resp.Data.Guangold = uinfo.GuanGold
		resp.Data.Loginday = uinfo.ContinueLoginDay
		resp.Data.Totalcnt = uinfo.CalcTotalCnt()
		resp.Data.Leftcnt = resp.Data.Totalcnt - uinfo.GetFromGuanCnt
		resp.Data.Maxget = mcfg.Max
		resp.Data.Minget = mcfg.Min
		resp.Data.Totalfetchcnt = uinfo.Achieve.SumGetGuan
		resp.Code = ERROR_OK
		break

	}

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

func HandlerWatchads(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp WatchadsResp
	resp.Code = 0

	/*for {
		uinfo, err := GetUserInfo(uuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if uinfo.WatchAddsTime == 0 {
			logger.Error("WatchAddsTime zero")
			resp.Message = "看视频次数已经耗尽"
			resp.Code = ERROR_WATCHADS_ZEOR
			break
		}

		uinfo.WatchAddsTime--
		err = SaveUserInfo(uinfo)
		if err != nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		resp.Code = ERROR_OK
		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
	var rdata GetcashReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//临时处理一下
		/*if rdata.Ver == "" {
			rdata.Ver = "2.0.0"
		}*/

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		drawnum := int(rdata.Money * 100)
		//需要判断一下金币是否足够
		if drawnum*100 > uinfo.RealGold {
			logger.Error("gold nor enough failed err=%v", err)
			resp.Message = "提现金币不足"
			resp.Code = ERROR_GETCASH_GOLDNOTENOUGH_FAILED
			break
		}

		//需要处理一下提现级别

		index := 0
		var info *WithDrawDesc
		if rdata.Ctype == 1 {
			index, info = uinfo.GetWithDrawData(rdata.Money)
		} else {
			index, info = uinfo.GetSpecialWithDrawData(rdata.Money)
		}

		if index == -1 || info == nil {
			logger.Error("AddWithDrawList failed err=%v", err)
			resp.Message = "网络错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if uinfo.Lv < info.Limitlv {
			logger.Error("AddWithDrawList failed err=%v", err)
			resp.Message = "完成日常任务可以提升人物等级哦~"
			resp.Code = ERROR_WITHDRAWLVLIMIT
			break
		}

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

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

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

		//如果是2.2.7版本开启提现次数限制
		if rdata.Ver == "2.2.7" && uinfo.GetCashCnt > 0 {
			logger.Error("HandlerGetcash GetCashCnt err=%v", err)
			resp.Message = "当天已经提现过了，请明天再来"
			resp.Code = ERROR_PRENOTFINISH
			break
		}

		if uinfo.SumLoginDay < info.Day {
			logger.Error("HandlerGetcash GetCashCnt err=%v", err)
			resp.Message = "累计登陆天数不足"
			resp.Code = ERROR_PRENOTFINISH
			break
		}

		//2.2.5版本开启自动审核
		checkcoin := 2
		if rdata.Ver == "2.2.5" || rdata.Ver == "2.2.6" || rdata.Ver == "2.2.7" {
			logger.Info("HandlerGetcash autocheckcoin")
			if drawnum <= 150 {
				//1.5挡位以下不需要审核
				checkcoin = 1 //临时关闭u
			}
		}

		gold, err := GetCashFromSDK(uuid, drawnum, rdata.Gameid, rdata.Channel, rdata.Openid, rdata.Nickname, rdata.Headurl, rdata.Ver, checkcoin)
		if err != nil {
			logger.Error("GetCashFromSDK failed err=%v", err)
			resp.Message = "从后台提现失败了"
			resp.Code = ERROR_GETCASH_FAILED
			break
		}

		//需要保存一下提现记录
		/*	sdata := new(WithDrawRecord)
			sdata.Coin = int(rdata.Money * 100)
			sdata.Create_time = int(time.Now().Unix())
			err = AddWithDrawList(uuid, sdata)
			if err != nil {
				logger.Error("AddWithDrawList failed err=%v", err)
				resp.Message = "网络错误"
				resp.Code = ERROR_SRV_ERROR
				break
			}*/

		uinfo.GetCashCnt++
		//如果是前六挡
		if info.Cid <= 6 && rdata.Ctype == 1 {
			uinfo.WithDraw.Cashdata[index].Isnew = 0
		}
		if rdata.Ctype == 2 {
			uinfo.WithDraw.SpecialCashdata[index].Isnew = 0
		}

		uinfo.RealGold = gold
		//uinfo.RealGold -= drawnum * 100

		resp.Data.Walletgold = uinfo.RealGold
		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerFetchreadgold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp FetchreadgoldResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerFetchreadgold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//加金币到后台
		addgold := uinfo.ReadNum * READGOLDMULTI
		if addgold == 0 {
			logger.Error("HandlerFetchreadgold err=%v", err)
			resp.Message = "没有金币可以领取"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		realgiold, readaddgold, err := AddCoinToSdk(uuid, addgold, rdata.Gameid, rdata.Channel, SDKOPGOLD_TYPEWE)
		if err != nil {
			logger.Error("HandlerFetchreadgold failed err=%v", err)
			resp.Message = "后台加金币失败"
			resp.Code = ERROR_SRV_ERROR
		}

		uinfo.RealGold = realgiold
		uinfo.ReadNum = 0

		err = SaveUserInfo(uinfo, uniqueuuid)
		if err != nil {
			logger.Error("HandlerFetchreadgold failed err=%v", err)
		}

		resp.Data.Curgoldnum = uinfo.RealGold
		resp.Data.Getgoldnum = readaddgold
		//resp.Data.Goldnum = uinfo.ReadNum * READGOLDMULTI

		resp.Code = ERROR_OK
		break
	}

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

func HandlerQueryReadGold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryReadGoldResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerQueryReadGold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		resp.Data.Goldnum = uinfo.ReadNum * READGOLDMULTI

		resp.Code = ERROR_OK
		break
	}

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

func HandlerQuerysigndata(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuerysigndataResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//此处要处理一下跨天逻辑
		uinfo.HandlePassDay(uuid, rdata.Channel)

		resp.Data.Continuessign = uinfo.SignSum
		resp.Data.IssignToday = uinfo.IsSignToday
		resp.Data.Signround = uinfo.SignRound

		logger.Info("HandlerQuerysigndata resp=%v", resp)

		SaveUserInfo(uinfo, uniqueuuid)
		resp.Code = ERROR_OK
		break
	}

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

func HandlerGetnewlevelreward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetnewlevelrewardResp
	resp.Code = 0
	var rdata GetnewlevelrewardReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGetnewlevelreward data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//判断是否可以领取
		if uinfo.LvRewardGet != 1 {
			logger.Error("LvRewardGet failed err=%v", err)
			resp.Message = "当前等级奖励已经领取过了"
			resp.Code = ERROR_LVREWARDALREADYGET
			break
		}

		cfg := GetUserLvConfig(uinfo.Lv)
		if cfg == nil {
			logger.Error("GetUserLvConfig failed err=%v", err)
			resp.Message = "网络错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		goldnum, _, err := AddCoinToSdk(uuid, cfg.Cash, rdata.Gameid, rdata.Channel, 101)
		if err != nil {
			logger.Error("AddCoinToSdk failed err=%v", err)
			resp.Message = "网络错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}
		uinfo.RealGold = goldnum
		//uinfo.RealGold += cfg.Cash

		if rdata.Rewardtype == 2 {
			goldnum, _, err = AddCoinToSdk(uuid, cfg.Extracash, rdata.Gameid, rdata.Channel, 104)
			if err != nil {
				logger.Error("AddCoinToSdk failed err=%v", err)
				resp.Message = "网络错误"
				resp.Code = ERROR_SRV_ERROR
				break
			}
			uinfo.RealGold = goldnum
			//uinfo.RealGold += cfg.Extracash
		}

		uinfo.LvRewardGet = 1 + rdata.Rewardtype

		resp.Data.Goldnum = uinfo.RealGold
		logger.Info("HandlerGetnewlevelreward gold=%v", uinfo.RealGold)
		//保存数据
		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerReadNumUpload(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp ReadNumUploadResp
	resp.Code = 1
	resp.Message = "success"
	var rdata ReadNumUploadReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerReadNumUpload data failed:%v,for:%v", err, data)
			resp.Message = "json 解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//先解析uuid
		params := strings.Split(rdata.Uid, "-")
		if len(params) != 3 {
			logger.Info("json decode HandlerReadNumUpload data failed:%v,for:%v", err, data)
			resp.Message = "参数不正确 请检查"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := params[2] + params[1]
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("HandlerReadNumUpload redis failed err=%v", err)
			resp.Message = "uid错误，无法查询到玩家信息"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		uinfo.ReadNum += rdata.Readnum
		err = SaveUserInfo(uinfo, uniqueuuid)
		if err != nil {
			logger.Info("HandlerReadNumUpload failed err=%v", err)
		}

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


func HandlerUploadscore(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp UploadhigestscoreResp
	resp.Code = 0
	resp.Message = "success"
	var rdata UploadhigestscoreReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerUploadscore data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if uinfo.Hfen >= rdata.Score {
			//resp.Message = "服务器错误"
			resp.Code = 0
			break
		}

		uinfo.Hfen = rdata.Score
		uinfo.AddToRank(uniqueuuid)
		//加入排行榜
		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

func HandlerTurntablebag(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp TurntablebagResp
	resp.Code = 0
	resp.Message = "success"
	var rdata TurntablebagReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerTurntablebag data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		goldnum, _, err := AddCoinToSdk(uuid, rdata.Num, rdata.Gameid, rdata.Channel, 104)
		if err != nil {
			logger.Error("AddCoinToSdk failed rdata=%v", rdata)
			resp.Message = "网络错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}
		uinfo.RealGold = goldnum

		resp.Data.Walletgold = goldnum
		resp.Data.Getgoldnum = rdata.Num
		//加入排行榜
		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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


func HandlerQueryrankinfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryrankinfoResp
	resp.Code = 0
	resp.Message = "success"
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerQueryrankinfo data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel

		selfrank := -1
		selfscore := int64(0)
		vv, err := redishandler.GetRedisClient().ZRevRangewithIndex(redis.USER_SCORE_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 Queryrankinfolist
					tmp.UniqueId = string(rinfobyte)
					tmp.Socre = rindo.Hfen
					tmp.Nickname = rindo.Nickname
					tmp.Headurl = rindo.HeadUrl
					tmp.Rank = rank

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

				if string(rinfobyte) == uniqueuuid {
					selfrank = rank
					selfscore = rindo.Hfen
				}
			}
		} else {
			logger.Error("HandlerUpdateUserInfo redisfailed ")
			resp.Code = 1
			resp.Message = "redisfailed"
			break
		}

		if selfrank == -1 {
			uinfo, err := GetUserInfo(uniqueuuid)
			if err != nil {
				logger.Info("GetUserInfo HandlerQueryrankinfo data failed:%v,for:%v", err, data)
				resp.Message = "GetUserInfo failed"
				resp.Code = 1
				break
			}

			resp.Data.Selfsocre = uinfo.Hfen
			resp.Data.Selfrank = 101 //表示100+
		} else {
			resp.Data.Selfrank = selfrank
			resp.Data.Selfsocre = selfscore
		}

		resp.Code = ERROR_OK
		break
	}

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


func HandlerSavadata(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp SavadataResp
	resp.Code = 0
	var rdata SavadataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerSavadata data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := redis.USER_SELFDATA_KEY + "_" + strconv.Itoa(uuid) + "_" + rdata.Channel
		 err := redishandler.GetRedisClient().HSet( uniqueuuid,rdata.Key,rdata.Value)
		if err != nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}


		resp.Code = ERROR_OK
		break
	}

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

func HandlerGetdata(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetdataResp
	resp.Code = 0
	var rdata GetdataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGetdata data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := redis.USER_SELFDATA_KEY + "_" + strconv.Itoa(uuid) + "_" + rdata.Channel
		str,err := redishandler.GetRedisClient().HGet( uniqueuuid,rdata.Key)
		if err != nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "success"
			resp.Code = 0
			break
		}

		resp.Data.Value = str
		resp.Code = ERROR_OK
		break
	}

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

func HandlerFetchredbag(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	llock.Lock()
	defer llock.Unlock()
	var resp FetchredbagResp
	resp.Code = 0
	var rdata FetchredbagReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerFetchredbag data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		readaddgold := uinfo.FetchRedPacket(rdata.Gameid, rdata.Channel, uuid)

		resp.Data.Walletgold = uinfo.RealGold
		resp.Data.Getgoldnum = readaddgold

		uinfo.IsNew = 0
		uinfo.FetchRdBagNum++

		//保存数据
		err = SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerUsersign(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp UsersignResp
	resp.Code = 0
	var rdata UsersignReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerUsersign data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if uinfo.IsSignToday == 1 {
			logger.Error("IsSignToday failed err=%v", err)
			resp.Message = "今日已经签过到啦"
			resp.Code = ERROR_SINGALREADYTODAY
			break
		}

		uinfo.SignSum++
		if uinfo.SignSum > 7 {
			uinfo.SignSum = 7
			logger.Error("uinfo.SignSum failed")
			resp.Message = "签到数据异常"
			resp.Code = ERROR_SINGDATAFAILED
			break
		}

		//获取配置
		cfg := jsonconf.GetSignConfig(uinfo.SignRound, uinfo.SignSum)
		if cfg == nil {
			uinfo.SignSum--
			logger.Error("GetSignConfig failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//uinfo.RealGold =
		goldnum, _, err := AddCoinToSdk(uuid, cfg.Num, rdata.Gameid, rdata.Channel, 107)
		if err != nil {
			uinfo.SignSum--
			logger.Error("AddCoinToSdk failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		uinfo.IsSignToday = 1
		uinfo.RealGold = goldnum
		//uinfo.RealGold += cfg.Num

		resp.Data.Goldnum = uinfo.RealGold
		resp.Data.Addgold = cfg.Num

		//保存数据
		err = SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerGettaskreward(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GettaskrewardResp
	resp.Code = 0
	var rdata GettaskrewardReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGettaskreward data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//需要先计算出任务或者成就
		var tasklist *TaskList
		//先查询一下当前的任务数据
		tasklist, err = GetTaskInfo(uuid, rdata.Tasktype, rdata.Channel)
		if err != nil || tasklist == nil {
			logger.Error("GetTaskInfo failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		err = uinfo.HandleGetTaskReward(&rdata, &resp, tasklist, uuid)
		logger.Info("HandlerGettaskreward tasklist=%v", tasklist)
		logger.Info("HandlerGettaskreward uinfo=%v", uinfo)
		if err != nil {
			logger.Error("HandleGetTaskReward failed err=%v", err)
			resp.Message = "奖励已经领取"
			resp.Code = ERROR_TASKCANNOTGET
			break
		}

		//保存数据
		err = SaveUserInfo(uinfo, uniqueuuid)
		err = SaveTaskInfo(uniqueuuid, rdata.Tasktype, tasklist)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerQuerytaskinfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuerytaskinfoResp
	resp.Code = 0
	var rdata QuerytaskinfoReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerQuerytaskinfo data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		uinfo.HandlePassDay(uuid, rdata.Channel)

		//需要先计算出任务或者成就
		var tasklist *TaskList
		//先查询一下当前的任务数据
		tasklist, err = GetTaskInfo(uuid, rdata.Tasktype, rdata.Channel)
		if err != nil || tasklist == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if rdata.Tasktype == 1 {
			tasklist = uinfo.CalcTaskList(tasklist, uniqueuuid)
		} else if rdata.Tasktype == 2 {
			tasklist = uinfo.CalcAchieveList(tasklist, uniqueuuid)
		} else {
			tasklist = uinfo.CalcTaskList(tasklist, uniqueuuid)
		}

		if tasklist == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		resp.Data.Taskdata = append(resp.Data.Taskdata, tasklist.Taskdata...)
		resp.Data.Fetchrdnum = uinfo.FetchRdBagNum

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerUpdatetaskandachieve(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	llock.Lock()
	defer llock.Unlock()
	var resp UpdatetaskResp
	resp.Code = 0
	var rdata UpdatetaskReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		switch rdata.Tasktype {
		case TASKTYPE_GETREDBAG:
			uinfo.Task.GetRedbagCnt += rdata.Value
			if uinfo.LeftFreeRB > 0 {
				uinfo.LeftFreeRB--
			}
			if uinfo.WatchAddsTime > 0 {
				uinfo.WatchAddsTime--
			}
		case TASKTYPE_WATCHADS:
			uinfo.Achieve.WatchAdsCnt += rdata.Value
			uinfo.Task.Watchads += rdata.Value
		/*case TASKTYPE_GETREDBAG:
			uinfo.Task.GetRedbagCnt += rdata.Value
		case TASKTYPE_WATCHADS:
			uinfo.Achieve.WatchAdsCnt += rdata.Value
			if uinfo.LeftFreeRB > 0 {
				uinfo.LeftFreeRB--
			}
			if uinfo.WatchAddsTime > 0 {
				uinfo.WatchAddsTime--
			}*/
		case TASKTYPE_KILLSTAR:
			uinfo.Achieve.KillStar += rdata.Value
		case TASKTYPE_USEITEM:
			uinfo.Task.UseItemCnt += rdata.Value
			uinfo.Achieve.SumUseItemCnt += rdata.Value
		case TASKTYPE_PLAYSMALLGAMES:
			uinfo.Task.PlaySmall += 1
		case TASKTYPE_SHAKETIME:
			uinfo.ShakeTime -= rdata.Value
			if uinfo.ShakeTime < 0 {
				uinfo.ShakeTime = 0
			}
		case TASKTYPE_HENUM:
			if uinfo.Task.CaiNum < rdata.Value{
				uinfo.Task.CaiNum = rdata.Value
			}

		}
		logger.Info("HandlerUpdatetaskandachieve uinfo=%v rdata=%v", uinfo, rdata)
		SaveUserInfo(uinfo, uniqueuuid)
		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerOnlinentf(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp OnlinentfResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerOnlinentf data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		uinfo.Task.OnlineMin++

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		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
	var rdata GetcashrecordReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGetcashrecord data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//	list, err := GetWithDrawList(uuid)
		/*if err != nil || list == nil {
			/*logger.Error("HandlerGetcashrecord failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}*/
		list, err := GetCashList(uuid, rdata.Gameid, rdata.Channel, 0, 100)
		if err != nil {
			logger.Error("HandlerGetcashrecord failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}
		if list != nil {
			resp.Data.Withdata = append(resp.Data.Withdata, *list...)
		}

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerQuerdrawinfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuerdrawinfoResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerQuerdrawinfo data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		//返回
		resp.Data.Cashdata = append(resp.Data.Cashdata, uinfo.WithDraw.Cashdata...)
		resp.Data.SpecialCashdata = append(resp.Data.SpecialCashdata, uinfo.WithDraw.SpecialCashdata...)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerDrawguangold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp DrawguangoldResp
	resp.Code = 0
	var rdata DrawguangoldReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}
		//首先判断一下存钱罐的金币是否足够
		if rdata.Goldnum > uinfo.GuanGold {
			logger.Error("guangold not enough rdata.Goldnum=%v uinfo.GuanGold=%v", rdata.Goldnum, uinfo.GuanGold)
			resp.Message = "存钱罐金币不足"
			resp.Code = ERROR_GUANGOLD_NOTENOUGH
			break
		}

		//判断一下是否满足提取条件
		totalcnt := uinfo.CalcTotalCnt()
		if totalcnt <= uinfo.GetFromGuanCnt {
			logger.Error("guancnt not enough ")
			resp.Message = "存钱罐次数不足"
			resp.Code = ERROR_GUANCNTNOTENOUGH
			break
		}

		//
		mcfg := jsonconf.GetMoneyBoxCfg(uinfo.Lv)
		if mcfg == nil {
			logger.Error("GetMoneyBoxCfg failed err=%v", err)
			resp.Message = "获取配置失败"
			resp.Code = ERROR_GETCONFIG_FAILED
			break
		}

		if rdata.Goldnum < mcfg.Min || rdata.Goldnum > mcfg.Max {
			logger.Error("GetMoneyBoxCfg failed err=%v", err)
			resp.Message = "从存钱罐提取金币不满足限制"
			resp.Code = ERROR_DRAWGUAN_FAILED
			break
		}

		//todo 此处需要调佣SDK接口通知金币变化
		goldnum, realgold, err := AddCoinToSdk(uuid, rdata.Goldnum, rdata.Gameid, rdata.Channel, 105)
		if err != nil {
			logger.Error("Drawgold failed err=%v", err)
			resp.Message = "从存钱罐提取金币失败了"
			resp.Code = ERROR_DRAWGOLD_FAILED
			break
		}

		uinfo.GetFromGuanCnt++
		uinfo.Achieve.SumGetGuan++
		uinfo.GuanGold = uinfo.GuanGold - rdata.Goldnum
		uinfo.RealGold = goldnum
		//uinfo.RealGold += rdata.Goldnum

		resp.Data.Guangold = uinfo.GuanGold
		resp.Data.Wallgold = uinfo.RealGold
		resp.Data.Totalfetchcnt = uinfo.Achieve.SumGetGuan
		resp.Data.Getgoldnum = realgold

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

}

func HandlerGetguangold(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp GetguangoldResp
	resp.Code = 0
	var rdata GetguangoldReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGetguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		mcfg := jsonconf.GetMoneyBoxCfg(uinfo.Lv)
		if mcfg == nil {
			logger.Error("GetMoneyBoxCfg failed err=%v", err)
			resp.Message = "获取配置失败"
			resp.Code = ERROR_GETCONFIG_FAILED
			break
		}

		uinfo.GuanGold += rdata.Goldnum
		if uinfo.GuanGold >= mcfg.Max {
			uinfo.GuanGold = mcfg.Max
		}

		resp.Data.Guangold = uinfo.GuanGold
		//uinfo.Task.GetGuanGold += rdata.Goldnum
		uinfo.Task.GetGuanGold++

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		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
	var rdata GetuserdataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerGetuserdata data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		data, err := GetUserInfo(uniqueuuid)
		if err != nil || data == nil {
			resp.Code = ERROR_SRV_ERROR
			resp.Message = "ERROR_SRV_ERROR"
			break
		}

		//此处处理一下从sdk拉取钱包金币数量
		gold, err := GetCoinFromSdk(uuid, rdata.Gameid, rdata.Channel)
		if err == nil {
			data.RealGold = gold
		} else {
			logger.Error("GetCoinFromSdk failed err=%v", err)
		}

		resp.Data.Walletgold = data.RealGold
		resp.Data.Guangold = data.GuanGold
		resp.Data.Leftredbagcnt = data.WatchAddsTime
		resp.Data.Userexp = data.Exp
		resp.Data.Userlv = data.Lv
		resp.Data.Leftfreeredbag = data.LeftFreeRB
		resp.Data.Sumloginday = data.SumLoginDay
		resp.Data.Shakeleftcnt = data.ShakeTime
		//SaveUserInfo(data, uniqueuuid)

		resp.Code = ERROR_OK
		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) {
	SetHeader(w)

	var resp UserLoginResp
	resp.Code = 0
	var rdata UserLoginReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerLogin data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		//此处需要做一下数据兼容 先判断uuid+channel的key是否存在
		//先判断一下是否是新用户
		isexist, err := redishandler.GetRedisClient().HExists(redis.USER_DATA_KEY, uniqueuuid)
		if err != nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		if !isexist {
			//不存在
			//属于新登录的玩家数据
			//需要判断是否存在老的版本的数据
			err = InitUserInfo(&rdata, &resp, uuid, uniqueuuid)
			/*isexist, err = redishandler.GetRedisClient().HExists(redis.USER_DATA_KEY, strconv.Itoa(uuid))
			if err == nil && isexist {
				logger.Info("HandlerLogin111111111111")
				//如果存在老的数据 做数据迁移
				oldstr, err := redishandler.GetRedisClient().HGet(redis.USER_DATA_KEY, strconv.Itoa(uuid))
				if err != nil {
					logger.Error("HandlerLogin redis failed err=%v,uuid=%v", err, uuid)
					resp.Message = "服务器错误"
					resp.Code = ERROR_SRV_ERROR
					break
				}
				err = redishandler.GetRedisClient().HSet(redis.USER_DATA_KEY, uniqueuuid, oldstr)
				if err != nil {
					logger.Error("HandlerLogin redis failed err=%v,uuid=%v", err, uuid)
					resp.Message = "服务器错误"
					resp.Code = ERROR_SRV_ERROR
					break
				}
				logger.Info("HandlerLogin uuid=%v do set oldstr=%v", uuid, oldstr)
				err = GetUserData(uuid, uniqueuuid, &rdata, &resp)
				if err == nil {
					//删除老的数据
					redishandler.GetRedisClient().HDel(redis.USER_DATA_KEY, strconv.Itoa(uuid))
					logger.Info("HandlerLogin uuid=%v do set", uuid)
				}
			} else {
				logger.Info("HandlerLogin22222222222222222")
				//不存在老的数据 之间走新号流程
				err = InitUserInfo(&rdata, &resp, uuid, uniqueuuid)
			}*/

		} else {
			//已经迁移过的数据之间返回
			//已经登陆过了 需要获取玩家数据
			err = GetUserData(uuid, uniqueuuid, &rdata, &resp)
		}

		if err != nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		resp.Code = ERROR_OK
		break
	}

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

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