package logic

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

func HandlerSyncuserdata(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)

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

	for {

		uinfo, err := GetUserInfo(uniqueuuid)

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

		uinfo.LastUpdateTime = int(time.Now().Unix())
		//此处要处理一下跨天逻辑
		uinfo.HandlePassDay(uuid, channel)

		resp.Data.Walletgold = uinfo.RealGold
		resp.Data.Guangold = uinfo.GuanGold
		resp.Data.Sumloginday = uinfo.SumLoginDay
		resp.Data.Nowtime = int(time.Now().Unix())
		resp.Data.Luckbaglefttime = uinfo.LuckyBagLeftTimes
		resp.Data.Leftfreeticket = uinfo.FreeTicket
		resp.Data.Leftticket = uinfo.Ticket
		break
	}

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

func HandlerUpdatedata(w http.ResponseWriter, data string, uniqueuuid string) {
	SetHeader(w)

	var resp UpdatedataResp
	resp.Code = 0
	resp.Message = "success"
	var rdata UpdatedataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerUpdatedata data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		//直接保存
		err := SaveUserSelfData(uniqueuuid, rdata.PlayerData)
		if err != nil {
			logger.Info("SaveUserSelfData HandlerUpdatedata data failed:%v,for:%v", err, data)
			resp.Message = "保存失败"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

		break
	}

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

func HandlerUploaduserbasicinfo(w http.ResponseWriter, data string, uniqueuuid string) {
	SetHeader(w)

	var resp UploaduserbasicinfoResp
	resp.Code = 0
	resp.Message = "success"
	var rdata UploaduserbasicinfoReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerUploaduserbasicinfo data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uinfo, err := GetUserInfo(uniqueuuid)

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

		uinfo.HeadUrl = rdata.Headurl
		uinfo.NickName = rdata.Nickname

		SaveUserInfo(uinfo, uniqueuuid)
		break
	}

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

func HandlerGettaskreward(w http.ResponseWriter, data string, uniqueuuid, gameid, channel 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
		}

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

		//需要先计算出任务或者成就
		var tasklist *TaskList
		//先查询一下当前的任务数据
		tasklist, err = GetTaskInfo(uuid, rdata.Tasktype, 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, gameid, channel)
		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_SRV_ERROR
			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, uniqueuuid, gameid, channel 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
		}

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

		uinfo.HandlePassDay(uuid, channel)

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

		if rdata.Tasktype == 1 {
			uinfo.CalcTaskList(tasklist, uniqueuuid)
		} else if rdata.Tasktype == 2 {
			tasklist = uinfo.CalcAchieveList(tasklist, uniqueuuid)
		} else {
			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.Huoyue = uinfo.Task.HuoYue

		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, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp UpdatetaskResp
	resp.Code = 0
	var rdata UpdatetaskReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerUpdatetaskandachieve data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil || uinfo == nil {
			logger.Error("HandlerUpdatetaskandachieve redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		switch rdata.Tasktype {
		case TASKTYPE_COSTTILI:
			uinfo.Task.CostTili += rdata.Value
		case TASKTYPE_REACH2000:
			uinfo.Task.OutScore += rdata.Value
		case TASKTYPE_WATCHADS:
			uinfo.Achieve.WatchAdsCnt += rdata.Value
			uinfo.Task.WatchAdCnt += rdata.Value
		case TASKTYPE_TURNTABLE:
			uinfo.Task.DrawTurnTableCnt += rdata.Value
		case TASKTYPE_LUCKYBAG:
			uinfo.Task.OpenLuckBagCnt += rdata.Value
		case TASKTYPE_ROCKETTIMES:
			uinfo.Task.UseRocketCnt += rdata.Value
		case TASKTYPE_RELIVECNT:
			uinfo.Task.RelivegCnt += rdata.Value
		case TASKTYPE_USEITEMTIMES:
			uinfo.Task.UseItemCnt += rdata.Value
		case ACHIEVE_KILLLINE:
			uinfo.Achieve.KillStar += rdata.Value
		case ACHIEVE_KILLLINELIE:
			uinfo.Achieve.KillStarLie += rdata.Value
		case ACHIEVE_GETSCORE:
			uinfo.Achieve.SumGetScore += int64(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, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp OnlinentfResp
	resp.Code = 0
	resp.Message = "success"
	for {

		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, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp GetcashrecordResp
	resp.Code = 0
	resp.Message = "success"
	for {

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

		break
	}

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

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

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

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

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

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

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

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

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

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

		resp.Data.Walletgold = gold

		//保存
		SaveUserInfo(uinfo, uniqueid)

		break

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

func HandlerQuerdrawinfo(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp QuerygetcashinfoResp
	resp.Code = 0
	resp.Message = "success"

	for {

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

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

		resp.Code = ERROR_OK
		break
	}

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

func HandlerQuerydrawreward(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp QuerydrawrewardResp
	resp.Code = 0
	resp.Message = "success"

	for {

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

		if uinfo.FreeTicket == 0 && uinfo.Ticket == 0 {
			//已经没有抽奖次数了
			logger.Info("GetUserInfo HandlerQuerydrawreward data failed:%v,for:%v", err, data)
			resp.Message = "已经没有抽奖次数了"
			resp.Code = 1
			break
		}

		addgold, rewardid := CalcTurnTableNum()

		/*if addgold == 0 {
			logger.Info("GetUserInfo HandlerQuerydrawreward data failed:%v,for:%v", err, data)
			resp.Message = "CalcTurnTableNumfaile"
			resp.Code = 1
			break
		}*/

		if addgold > 0 {
			realgold, err := AddCoinToSdk(uuid, addgold, gameid, channel, REDBAGTYPE_106)
			if err != nil {
				logger.Info("GetUserInfo HandlerQuerydrawreward data failed:%v,for:%v", err, data)
				resp.Message = "后台加金币失败了"
				resp.Code = 1
				break
			}

			uinfo.RealGold = realgold
		}

		if uinfo.FreeTicket > 0 {
			uinfo.FreeTicket--
		} else {
			uinfo.Ticket--
		}

		SaveUserInfo(uinfo, uniqueuuid)
		resp.Data.Getgold = addgold
		resp.Data.Walletgold = uinfo.RealGold
		resp.Data.Rewardid = rewardid
		resp.Data.Leftfreeticket = uinfo.FreeTicket
		resp.Data.Leftticket = uinfo.Ticket

		resp.Code = ERROR_OK
		break
	}

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

func HandlerQueryrankinfo(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp QueryrankinfoResp
	resp.Code = 0
	resp.Message = "success"

	for {
		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.HighScore
					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.HighScore
				}
			}
		} 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.HighScore
			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 HandlerUploadhigestscore(w http.ResponseWriter, data string, uniqueuuid, gameid, channel 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 HandlerUploadhigestscore data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil {
			logger.Info("GetUserInfo HandlerUploadhigestscore data failed:%v,for:%v", err, data)
			resp.Message = "GetUserInfo failed"
			resp.Code = 1
			break
		}

		if rdata.Score < uinfo.HighScore {
			logger.Info("GetUserInfo HandlerUploadhigestscore data failed:%v,for:%v", err, data)
			resp.Message = "分数不足最高分"
			resp.Code = 1
			break
		}

		uinfo.HighScore = rdata.Score

		uinfo.AddToRank()
		//加入排行榜
		SaveUserInfo(uinfo, uniqueuuid)
		resp.Code = ERROR_OK
		break
	}

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

func HandlerDosign(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp DosignResp
	resp.Code = 0
	resp.Message = "success"
	var rdata DosignReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerDosign data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uinfo, err := GetUserInfo(uniqueuuid)
		if err != nil {
			logger.Info("GetUserInfo HandlerDosign data failed:%v,for:%v", err, data)
			resp.Message = "GetUserInfo failed"
			resp.Code = 1
			break
		}

		if uinfo.IsSignToday == 1 {
			logger.Info(" HandlerDosign issign failed:%v,for:%v", err, data)
			resp.Message = "当天已签到"
			resp.Code = 1
			break
		}

		uinfo.IsSignToday = 1
		uinfo.SignSum++
		if uinfo.SignSum > 7 {
			uinfo.SignSum = 1
			uinfo.SignRound++
		}

		cfg := jsonconf.GetsignConfig(uinfo.SignSum)
		if cfg == nil {
			logger.Info("GetUserInfo HandlerDosign data failed:%v,for:%v", err, data)
			resp.Message = "参数错误"
			resp.Code = 1
			break
		}

		readgold := 0
		readgold, err = AddCoinToSdk(uuid, cfg.Sign_coin, gameid, channel, REDBAGTYPE_107)
		if err != nil {
			logger.Info("GetUserInfo HandlerDosign data failed:%v,for:%v", err, data)
			resp.Message = "后台失败！"
			resp.Code = 1
			break
		}

		if rdata.Ftype == 2 {
			readgold, err = AddCoinToSdk(uuid, cfg.Video_coin, gameid, channel, REDBAGTYPE_107)
			if err != nil {
				logger.Info("GetUserInfo HandlerDosign data failed:%v,for:%v", err, data)
				resp.Message = "后台失败！"
				resp.Code = 1
				break
			}
		}

		uinfo.RealGold = readgold

		resp.Data.Curday = uinfo.SignSum
		resp.Data.Issigntaday = uinfo.IsSignToday
		resp.Data.Walletgold = uinfo.RealGold

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

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

func HandlerFetchoffliengold(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp FetchoffliengoldResp
	resp.Code = 0
	for {

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

		if uinfo.OfflineGold <= 0 {
			logger.Info("GetUserInfo HandlerFetchoffliengold data failed:%v,for:%v", err, data)
			resp.Message = "没有离线金币可以领取"
			resp.Code = 1
			break
		}

		readgold, err := AddCoinToSdk(uuid, uinfo.OfflineGold, gameid, channel, REDBAGTYPE_106)
		if err != nil {
			logger.Info("GetUserInfo HandlerFetchoffliengold data failed:%v,for:%v", err, data)
			resp.Message = "后台失败！"
			resp.Code = 1
			break
		}

		uinfo.RealGold = readgold

		resp.Data.Walletgold = uinfo.RealGold
		resp.Data.Getgold = uinfo.OfflineGold

		uinfo.OfflineGold = 0

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

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

func HandlerQuersigndata(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)
	var resp QuersigndataResp
	resp.Code = 0
	for {

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

		resp.Data.Curday = uinfo.SignSum
		resp.Data.Issigntaday = uinfo.IsSignToday

		resp.Code = ERROR_OK
		break
	}

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

func HandlerFetchluckybag(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)

	var resp FetchluckybagResp
	resp.Code = 0

	for {

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

		//先判断次数是否足够
		if uinfo.LuckyBagLeftTimes < 1 {
			logger.Info("GetUserInfo HandlerFetchluckybag data failed:%v,for:%v", err, data)
			resp.Message = "当日已经没有福袋可以领取了！"
			resp.Code = 1
			break
		}

		addcoin := CalcLuckYBagNum()
		if addcoin == 0 {
			logger.Info("GetUserInfo HandlerFetchluckybag data failed:%v,for:%v", err, data)
			resp.Message = "CalcLuckYBagNum！"
			resp.Code = 1
			break
		}

		realgold, err := AddCoinToSdk(uuid, addcoin, gameid, channel, REDBAGTYPE_106)
		if err != nil {
			logger.Info("GetUserInfo HandlerFetchluckybag data failed:%v,for:%v", err, data)
			resp.Message = "后台加金币失败了"
			resp.Code = 1
			break
		}

		uinfo.RealGold = realgold
		uinfo.LuckyBagLeftTimes--

		resp.Data.Wallgold = uinfo.RealGold
		resp.Data.Lefttimes = uinfo.LuckyBagLeftTimes
		resp.Data.Getgoldnum = addcoin

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

func HandlerFetchfenredbag(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)

	var resp FetchfenredbagResp
	resp.Code = 0
	var rdata FetchfenredbagReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {

		if err != nil {
			logger.Info("json decode HandlerFetchfenredbag data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}

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

		cfg := jsonconf.GetRedPackageConfig(rdata.Id)
		if cfg == nil {
			logger.Info("GetUserInfo HandlerFetchfenredbag data failed:%v,for:%v", err, data)
			resp.Message = "参数错误"
			resp.Code = 1
			break
		}

		//需要判断一下当天是否已经领取过了
		if uinfo.IsRedIdInList(rdata.Id) {
			logger.Info("GetUserInfo HandlerFetchfenredbag data failed:%v,for:%v", err, data)
			resp.Message = "此档位奖励已经领取过了！"
			resp.Code = 1
			break
		}

		addgold := cfg.Free_coin
		readgold := 0
		readgold, err = AddCoinToSdk(uuid, cfg.Free_coin, gameid, channel, REDBAGTYPE_103)
		if err != nil {
			logger.Info("GetUserInfo HandlerFetchfenredbag data failed:%v,for:%v", err, data)
			resp.Message = "后台失败！"
			resp.Code = 1
			break
		}

		if rdata.Ftype == 2 {
			addgold += cfg.Video_coin
			readgold, err = AddCoinToSdk(uuid, cfg.Video_coin, gameid, channel, REDBAGTYPE_106)
			if err != nil {
				logger.Info("GetUserInfo HandlerFetchfenredbag data failed:%v,for:%v", err, data)
				resp.Message = "后台失败！"
				resp.Code = 1
				break
			}
		}

		uinfo.RealGold = readgold
		uinfo.RedBagFetchIdlist = append(uinfo.RedBagFetchIdlist, rdata.Id)

		resp.Data.Wallgold = uinfo.RealGold
		resp.Data.Getgoldnum = addgold

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

func HandlerDrawguangold(w http.ResponseWriter, data string, uniqueuuid, gameid, channel 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
		}

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

		if rdata.Goldnum == 0 || uinfo.GuanGold < rdata.Goldnum {
			logger.Info("GetUserInfo HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "Goldnum is zero"
			resp.Code = 1
			break
		}
		realgold, err := AddCoinToSdk(uuid, rdata.Goldnum, gameid, channel, REDBAGTYPE_105)
		if err != nil {
			logger.Info("GetUserInfo HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "后台提现失败"
			resp.Code = 1
			break
		}

		uinfo.RealGold = realgold

		uinfo.GuanGold -= rdata.Goldnum

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

func HandlerGetguangold(w http.ResponseWriter, data string, uniqueuuid, gameid, channel 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
		}

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

		uinfo.GuanGold += rdata.Goldnum
		if uinfo.GuanGold > GUANGOLDNUMLIMIT {
			uinfo.GuanGold = GUANGOLDNUMLIMIT
		}

		resp.Data.Guangold = uinfo.GuanGold

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = ERROR_OK
		break
	}

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

func HandlerLogin(w http.ResponseWriter, data string, uniqueuuid, gameid, channel string, uuid int) {
	SetHeader(w)

	var resp UserLoginResp
	resp.Code = 0

	for {

		//先判断一下是否是新用户
		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(&resp, uniqueuuid, gameid, channel, uuid)

			resp.Data.Offlinegold = 0
		} else {
			uinfo, err := GetUserInfo(uniqueuuid)

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

			resp.Data.Guangold = uinfo.GuanGold
			gold, _ := GetCoinFromSdk(uuid, gameid, channel)
			uinfo.RealGold = gold
			resp.Data.Walletgold = gold

			resp.Data.Isnew = 0

			//需要计算一下是否有离线金币
			offset := (int(time.Now().Unix()) - uinfo.LastUpdateTime) / 60
			if offset > 10 {
				offgold := int(float32(offset-10) * 1.5)
				if offgold > 150 {
					offgold = 150
				}

				uinfo.OfflineGold = offgold
				uinfo.LastUpdateTime = int(time.Now().Unix())
			}

			resp.Data.Offlinegold = uinfo.OfflineGold
			SaveUserInfo(uinfo, uniqueuuid)
		}

		pdata, err := GetUserSelfData(uniqueuuid)

		/*if err != nil {
			logger.Info("GetUserSelfData HandlerLogin data failed:%v,for:%v", err, data)
			resp.Message = "GetUserSelfData failed"
			resp.Code = 1
			break
		}*/
		resp.Data.PlayerData = pdata

		resp.Code = ERROR_OK
		break
	}

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

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