package logic

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

var llock sync.Mutex

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 = 1
			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 = 1
			break
		}

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

		resp.Code = 0
		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 = 1
			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 = 1
			break
		}

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

		if uinfo.PassLevel < info.Limitlv {
			logger.Error("AddWithDrawList failed err=%v", err)
			resp.Message = "当前通关等级不足"
			resp.Code = 3
			break
		}

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

		if info.Preisfind == 0 {
			logger.Error("HandlerGetcash Preisfind err=%v", err)
			resp.Message = "请先完成前一档提现"
			resp.Code = 5
			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 = 6
			break
		}

		if info.Cid == 6 {
			if uinfo.ContinueLoginDay < info.Logindaylimit {
				logger.Error("HandlerGetcash GetCashCnt err=%v", err)
				resp.Message = "连续登陆天数不足"
				resp.Code = 7
				break
			}
		}else {
			if uinfo.SumLoginDay < info.Logindaylimit {
				logger.Error("HandlerGetcash GetCashCnt err=%v", err)
				resp.Message = "累计登陆天数不足"
				resp.Code = 7
				break
			}
		}


		//2.2.5版本开启自动审核
		checkcoin := 2
		if rdata.Ver == "2.2.5" || rdata.Ver == "2.2.6" || rdata.Ver == "2.3.2" {
			logger.Info("HandlerGetcash autocheckcoin")
			if drawnum <= 200 {
				//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 = 8
			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 = 0
		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 = 1
			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 = 1
			break
		}

		uinfo.Task.OnlineMin++

		SaveUserInfo(uinfo, uniqueuuid)

		resp.Code = 0
		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 = 1
			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 = 1
			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 = 1
			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 = 1
			break
		}

		resp.Data.Taskdata = append(resp.Data.Taskdata, tasklist.Taskdata...)

		resp.Code = 0
		break
	}

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

}

func HandlerQuerygunbonus(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuerygunbonusResp
	resp.Code = 0
	var rdata CommReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerQuerygunbonus data failed:%v,for:%v", err, data)
			resp.Message = "网络错误"
			resp.Code = 1
			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 = 1
			break
		}

		resp.Data.Finished = append(resp.Data.Finished,uinfo.GunBonus...)

		resp.Code = 0
		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 = 1
			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 = 1
			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 = 1
			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 = 1
			break
		}

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

		resp.Code = 0
		break
	}

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

}

func HandlerQuersigndata(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QuersigndataResp
	resp.Code = 0
	var rdata CommReq
	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 = 1
			break
		}

		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		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 = 0
		break
	}

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

func HandlerDosign(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp DosignResp
	resp.Code = 0
	resp.Message = "success"
	var rdata CommReq
	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 = 1
			break
		}
		//需要加上渠道才是唯一的玩家id，不同渠道视为不同数据
		uniqueuuid := strconv.Itoa(uuid) + rdata.Channel
		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
		}

		sub := len(cfg.Reward) / 2
		for i := 0; i < sub; i++ {
			rtype := cfg.Reward[i*2]
			rnum := cfg.Reward[i*2+1]
			resp.Data.Rewardtype = rtype
			if rtype == 1 {
				resp.Data.Getcurhuobi = rnum
			}else if rtype == 2 {
				readgold := 0
				readgold,  err = AddCoinToSdk(uuid, rnum, rdata.Gameid, rdata.Channel, 100)
				if err != nil {
					logger.Info("GetUserInfo HandlerDosign data failed:%v,for:%v", err, data)
					resp.Message = "后台失败！"
					resp.Code = 1
					break
				}
				uinfo.RealGold = readgold
			}else {
				logger.Error("HandlerDosign err")
			}
		}






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

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

	//回包
	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 HandlerUpdatetaskandachieve data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = 1
			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 = 1
			break
		}

		switch rdata.Tasktype {
		case TASKTYPE_HEQIANG:
			uinfo.Task.HeQiang += rdata.Value
			uinfo.Achieve.HeQiang += rdata.Value
		case TASKTYPE_JIEQIANG:
			uinfo.Task.JieQiang += rdata.Value
			uinfo.Achieve.JieQiang += rdata.Value
		case TASKTYPE_WATCHADS:
			uinfo.Task.WatchAdCnt += rdata.Value
			uinfo.Achieve.WatchAdsCnt += rdata.Value
		case TASKTYPE_GETFLYBOX:
			uinfo.Task.GetKongBox += rdata.Value
		case TASKTYPE_TURNTABLE:
			uinfo.Task.TurnTableCnt += rdata.Value
		case TASKTYPE_SHOPBUY:
			uinfo.Task.ShopBuyGun += rdata.Value
		case TASKTYPE_PASSLEVEL:
			uinfo.Task.PassLevel += rdata.Value
			uinfo.Achieve.PassLevel += rdata.Value
		default:
			logger.Error("HandlerUpdatetaskandachieve type failed")
		}
		logger.Info("HandlerUpdatetaskandachieve uinfo=%v rdata=%v", uinfo, rdata)
		SaveUserInfo(uinfo, uniqueuuid)
		resp.Code = 0
		break
	}

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

}

func HandlerUploadtili(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	llock.Lock()
	defer llock.Unlock()
	var resp UploadtiliResp
	resp.Code = 0
	var rdata UploadtiliReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Info("json decode HandlerUploadspeciallevel data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = 1
			break
		}

		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 = 1
			break
		}

		uinfo.Tili = rdata.Tili


		SaveUserInfo(uinfo,uniqueuuid)

		resp.Code = 0
		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 = "json解析错误"
			resp.Code = 1
			break
		}

		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 = 1
			break
		}



		if rdata.Rtype == 1 {
			//等级红包

			if uinfo.JiRedNum >= uinfo.GunLevel {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "没有可以领取的等级红包"
				resp.Code = 1
				break
			}

			cfg := jsonconf.GetGunLvRdNum(rdata.Param)
			if cfg == nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "获取配置失败！"
				resp.Code = 1
				break
			}

			addgold := int(cfg.Luckybag * 10000)
			realgold, err := AddCoinToSdk(uuid, addgold, rdata.Gameid, rdata.Channel, 108)
			if err !=nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "服务器错误！"
				resp.Code = 1
				break
			}

			resp.Data.Getgold = addgold
			resp.Data.Walletgold = realgold


			uinfo.JiRedNum ++



		}else if rdata.Rtype == 2 {
			//关卡红包
			curprocess := (uinfo.PassLevel-1) / 3
			if uinfo.GuanRedNum >= curprocess {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "没有可以领取的等级红包"
				resp.Code = 1
				break
			}

			cfg := jsonconf.GetWinLvRdNum(uinfo.GuanRedNum+1)
			if cfg == nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "获取配置失败！"
				resp.Code = 1
				break
			}

			addgold := int(cfg.LuckyBag * 10000)
			realgold, err := AddCoinToSdk(uuid, addgold, rdata.Gameid, rdata.Channel, 108)
			if err !=nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "服务器错误！"
				resp.Code = 1
				break
			}

			resp.Data.Getgold = addgold
			resp.Data.Walletgold = realgold

			uinfo.GuanRedNum ++
		}else if rdata.Rtype == 3{
			//时长红包
			if uinfo.RandNum <= 0 {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "没有可以领取的随机红包次数了！"
				resp.Code = 1
				break
			}


			cnt := RANDNUMLIMIT +1 - uinfo.RandNum
			cfg := jsonconf.GetOnlieRdNum(cnt)
			if cfg == nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "获取配置失败！"
				resp.Code = 1
				break
			}

			getnum := int(cfg.Luckybag*10000)
			realgold, err := AddCoinToSdk(uuid, getnum, rdata.Gameid, rdata.Channel, 108)
			if err !=nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "服务器错误！"
				resp.Code = 1
				break
			}

			resp.Data.Getgold = getnum
			resp.Data.Walletgold = realgold

			uinfo.RandNum--
		}else if rdata.Rtype == 4{
			cfg := jsonconf.GetInvestConfig(rdata.Param)
			if cfg == nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "获取配置失败！"
				resp.Code = 1
				break
			}
			sub := len(cfg.Reward) / 2
			for i := 0; i < sub; i++ {
				rtype := cfg.Reward[i*2]
				rnum := cfg.Reward[i*2+1]
				if rtype != 3 {
					continue
				}else {
					readgold := 0
					readgold,  err = AddCoinToSdk(uuid, rnum, rdata.Gameid, rdata.Channel, 100)
					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.Getgold = rnum
					resp.Data.Walletgold = readgold
					break
				}

			}

		} else if rdata.Rtype == 5 {
			isin := false
			for _,v := range uinfo.GunBonus {
				if v == rdata.Param {
					isin = true
					break
				}
			}

			if isin {
				logger.Info("GetUserInfo HandlerFetchredbag data failed:%v,for:%v", err, data)
				resp.Message = "已经领取过了！"
				resp.Code = 1
				break
			}

			cfg := jsonconf.GetGunBigBonusCfg(rdata.Param)
			if cfg == nil {
				logger.Info("GetUserInfo HandlerFetchredbag data failed:%v,for:%v", err, data)
				resp.Message = "获取配置失败！"
				resp.Code = 1
				break
			}


			getnum := int(cfg.Luckybag)
			realgold, err := AddCoinToSdk(uuid, getnum, rdata.Gameid, rdata.Channel, 108)
			if err !=nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "服务器错误！"
				resp.Code = 1
				break
			}

			resp.Data.Getgold = getnum
			resp.Data.Walletgold = realgold

			uinfo.GunBonus = append(uinfo.GunBonus,rdata.Param)
			sort.Ints(uinfo.GunBonus)
		}else {
			/*if uinfo.SpecialLevel <= uinfo.SpecialNum {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "没有可以领取的随机红包次数了！"
				resp.Code = 1
				break
			}

			getnum := rand.Intn(300) + 300
			realgold, err := AddCoinToSdk(uuid, getnum, rdata.Gameid, rdata.Channel, 108)
			if err !=nil {
				logger.Error("HandlerFetchredbag failed err=%v", err)
				resp.Message = "服务器错误！"
				resp.Code = 1
				break
			}

			resp.Data.Getgold = getnum
			resp.Data.Walletgold = realgold

			uinfo.SpecialNum++*/
			logger.Error("HandlerFetchredbag not right")
			resp.Message = "类型不正确"
			resp.Code = 1
			break
		}



		SaveUserInfo(uinfo,uniqueuuid)

		resp.Data.Timeredbagleft = uinfo.RandNum
		resp.Data.Guanrednum = uinfo.GuanRedNum
		resp.Data.Gunrednum = uinfo.JiRedNum

		resp.Code = 0
		break
	}

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

}

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

		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 = 1
			break
		}

		if rdata.Level > uinfo.SpecialLevel {
			uinfo.SpecialLevel = rdata.Level
		}


		SaveUserInfo(uinfo,uniqueuuid)

		resp.Code = 0
		break
	}

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

}

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

		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 = 1
			break
		}

		if rdata.Level > uinfo.GunLevel {
			uinfo.GunLevel = rdata.Level
		}


		SaveUserInfo(uinfo,uniqueuuid)

		resp.Code = 0
		break
	}

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

}

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

		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 = 1
			break
		}

		logger.Info("HandlerUploadlevel uinfo=%v rdata=%v",uinfo.PassLevel,rdata.Level)
		if rdata.Level > uinfo.PassLevel {
			uinfo.PassLevel = rdata.Level
		}


		SaveUserInfo(uinfo,uniqueuuid)

		resp.Code = 0
		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 = 1
			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 = 2
			break
		}
		if list != nil {
			resp.Data.Withdata = append(resp.Data.Withdata, *list...)
		}

		resp.Code = 0
		break
	}

	//回包
	respstr, _ := json.Marshal(&resp)
	fmt.Fprint(w, 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 = 1
			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 = 1
			break
		}

		if !isexist {
			//不存在

				//不存在老的数据 之间走新号流程
				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 = 1
			break
		}

		resp.Code = 0
		break
	}

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

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

func (u *UserData) HandlePassDay(uuid int, channel string) {
	isdiffday := false
	nowtime := time.Now()
	lasttime := time.Unix(int64(u.LastLoginTime), 0)
	nowdaynum := time.Now().Day()
	lastdaynum := time.Unix(int64(u.LastLoginTime), 0).Day()
	nowtimestamp := time.Date(nowtime.Year(), nowtime.Month(), nowtime.Day(), 0, 0, 0, 0, nowtime.Location())
	lasttimestamp := time.Date(lasttime.Year(), lasttime.Month(), lasttime.Day(), 0, 0, 0, 0, lasttime.Location())

	logger.Info("HandlePassDay lasttime=%v,lasttimestamp=%v", lasttime, lasttimestamp)
	if nowdaynum == lastdaynum {
		//同一天
		if int64(u.LastLoginTime)-time.Now().Unix() > 86400 {
			//已经过了很多天了
			//u.LastLoginTime = int(time.Now().Unix())
			u.ContinueLoginDay = 1
			isdiffday = true
		} else {
			//t同一天 不做处理
		}
	} else {
		//不是同一天了
		isdiffday = true
		if nowtimestamp.Unix() != lasttimestamp.Unix()+86400 {
			//超过一天了
			u.ContinueLoginDay = 1
		} else {
			u.ContinueLoginDay++
		}
		logger.Info("HandlePassDay now=%v,last=%v", nowtimestamp.Unix(), lasttimestamp.Unix())
	}

	if isdiffday {
		//跨天了
		u.SumLoginDay++
		u.WatchAddsTime = WATCH_ADD_DAY_LIMIT
		//todo 重置任务相关的数据
		u.GetFromGuanCnt = 0
		u.GetCashCnt = 0
		u.RandNum = RANDNUMLIMIT

		//任务数据重置
		u.Task.PassLevel = 0
		u.Task.ShopBuyGun = 0
		u.Task.TurnTableCnt = 0
		u.Task.GetKongBox = 0
		u.Task.JieQiang = 0
		u.Task.HeQiang = 0
		u.Task.WatchAdCnt = 0
		u.Task.OnlineMin = 0

		//签到数据处理
		u.IsSignToday = 0
		if u.SignSum >= 7 {
			//进入新的一轮
			u.SignSum = 0
			u.SignRound++
		}
	}

	u.LastLoginTime = int(nowtime.Unix())
	uniqueid := strconv.Itoa(uuid) + channel
	SaveUserInfo(u, uniqueid)
}

func GetUserData(uuid int, uniqueuid string, req *UserLoginReq, resp *UserLoginResp) error {
	data, err := GetUserInfo(uniqueuid)
	if err != nil || data == nil {
		resp.Code = 1
		resp.Message = "ERROR_SRV_ERROR"
		return err
	}

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

	//需要处理下提现表信息 等待提现表
	err = data.ReInitWithDraw(uniqueuid)
	if err != nil {
		logger.Error("GetUserData ReInitWithDraw err=%v", err)
	}

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



	SaveUserInfo(data, uniqueuid)

	resp.Data.Walletgold = data.RealGold
	resp.Data.Curji = data.GunLevel
	resp.Data.Curlevel = data.PassLevel
	resp.Data.Guanrednum = data.GuanRedNum
	resp.Data.Jirednum = data.JiRedNum
	resp.Data.Randnum = data.RandNum
	resp.Data.Speciallevel = data.SpecialLevel
	resp.Data.Specialguannum = data.SpecialNum
	resp.Data.Tili = data.Tili

	logger.Info("GetUserData resp=%+v",resp)

	return nil
}