package logic

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

func HandlerQueryguaninfo(w http.ResponseWriter, data string, uuid int) {
	SetHeader(w)
	var resp QueryguaninfoResp
	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
		}

		//获取存钱罐等级配置
		mcfg := jsonconf.GetMoneyBoxCfg(uinfo.Lv)
		if mcfg == nil {
			logger.Error("GetMoneyBoxCfg failed err=%v", err)
			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.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
		}
		uinfo, err := GetUserInfo(uuid)
		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
		}

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

		index, info := uinfo.GetWithDrawData(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("AddWithDrawList failed err=%v", err)
			resp.Message = "新人专享只能提取一次"
			resp.Code = ERROR_PRENOTFINISH
			break
		}

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

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

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

		uinfo.RealGold -= drawnum * 100

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

		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

	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
		}

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

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

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

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

		uinfo.LvRewardGet = 1 + rdata.Rewardtype

		//保存数据
		SaveUserInfo(uinfo)

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

		_, err = AddCoinToSdk(uuid, cfg.Num, rdata.Gameid, rdata.Channel, 100)
		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 += cfg.Num

		resp.Data.Goldnum = uinfo.RealGold

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

		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
		}
		uinfo, err := GetUserInfo(uuid)
		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)
		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)
		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)
		err = SaveTaskInfo(uinfo.Userid, 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
		}
		uinfo, err := GetUserInfo(uuid)
		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)
		if err != nil || tasklist == nil {
			logger.Error("redis failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

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

		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.Code = ERROR_OK
		break
	}

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

}

func HandlerUpdatetaskandachieve(w http.ResponseWriter, data 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 HandlerDrawguangold data failed:%v,for:%v", err, data)
			resp.Message = "json解析错误"
			resp.Code = ERROR_JSONUNMASH_ERROR
			break
		}
		uinfo, err := GetUserInfo(uuid)
		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_PASSLEVEL:
			uinfo.Task.PassLevel += rdata.Value
		case TASKTYPE_GETREDBAG:
			uinfo.Task.GetRedbagCnt += rdata.Value
		case TASKTYPE_WATCHADS:
			uinfo.Achieve.WatchAdsCnt += rdata.Value
		case TASKTYPE_KILLSTAR:
			uinfo.Achieve.KillStar += rdata.Value
		case TASKTYPE_USEITEM:
			uinfo.Task.UseItemCnt += rdata.Value
			uinfo.Achieve.SumUseItemCnt += rdata.Value
		}
		logger.Info("HandlerUpdatetaskandachieve uinfo=%v rdata=%v", uinfo, rdata)
		SaveUserInfo(uinfo)
		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
	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
		}

		uinfo.Task.OnlineMin++

		SaveUserInfo(uinfo)

		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
	for {
		list, err := GetWithDrawList(uuid)
		if err != nil || list == nil {
			logger.Error("HandlerGetcashrecord failed err=%v", err)
			resp.Message = "服务器错误"
			resp.Code = ERROR_SRV_ERROR
			break
		}

		resp.Data.Withdata = append(resp.Data.Withdata, list.Withdata...)

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

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

		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 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("guangold not enough ")
			resp.Message = "ERROR_SRV_ERROR"
			resp.Code = ERROR_GUANGOLD_NOTENOUGH
			break
		}

		uinfo.GetFromGuanCnt++
		uinfo.Achieve.SumGetGuan++
		//
		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接口通知金币变化
		_, err = AddCoinToSdk(uuid, rdata.Goldnum, rdata.Gameid, rdata.Channel, 100)
		if err != nil {
			logger.Error("Drawgold failed err=%v", err)
			resp.Message = "从存钱罐提取金币失败了"
			resp.Code = ERROR_DRAWGOLD_FAILED
			break
		}

		uinfo.GuanGold = uinfo.GuanGold - rdata.Goldnum
		uinfo.RealGold += rdata.Goldnum

		resp.Data.Guangold = uinfo.GuanGold
		resp.Data.Wallgold = uinfo.RealGold

		SaveUserInfo(uinfo)

		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
		}

		uinfo, err := GetUserInfo(uuid)
		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)

		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
		}

		data, err := GetUserInfo(uuid)
		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
		}

		resp.Data.Walletgold = data.RealGold
		resp.Data.Guangold = data.GuanGold
		resp.Data.Leftads = data.WatchAddsTime
		resp.Data.Userexp = data.Exp
		resp.Data.Userlv = data.Lv
		SaveUserInfo(data)

		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
		}

		//先判断一下是否是新用户
		isexist, err := redishandler.GetRedisClient().HExists(redis.USER_DATA_KEY, strconv.Itoa(uuid))
		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)
		} else {
			//已经登陆过了 需要获取玩家数据
			err = GetUserData(uuid, &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))
}