package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"bytes"
	"common/logger"
	"common/redis"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"io/ioutil"
	"net/http"
	"sort"
	"strconv"
	"time"
)

func (v *TaskList) Len() int {
	return len(v.Taskdata)
}

func (v *TaskList) Swap(i, j int) {
	v.Taskdata[i], v.Taskdata[j] = v.Taskdata[j], v.Taskdata[i]
}

func (v *TaskList) Less(i, j int) bool {
	if v.Taskdata[i].Taskstatus == v.Taskdata[j].Taskstatus {
		return v.Taskdata[i].Taskid < v.Taskdata[j].Taskid
	}
	return v.Taskdata[i].Taskstatus > v.Taskdata[j].Taskstatus
}

func SetHeader(w http.ResponseWriter) {
	w.Header().Set("Access-Control-Allow-Origin", "*") //允许访问所有域
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Uuid")
}

func SaveUserInfo(data *UserData, uniqueid string) error {

	savestr, err := json.Marshal(data)
	if err != nil {
		return err
	}

	err = redishandler.GetRedisClient().HSet(redis.USER_DATA_KEY, uniqueid, string(savestr))

	return err
}

func GetUserInfo(uniqueid string) (*UserData, error) {

	data, err := redishandler.GetRedisClient().HGet(redis.USER_DATA_KEY, uniqueid)
	if err != nil {
		return nil, err
	}
	var tmp UserData
	err = json.Unmarshal([]byte(data), &tmp)
	if err != nil {
		return nil, err
	}

	return &tmp, nil
}

func GetUserLvConfig(lv int) *jsonconf.LevelDesc {
	for _, val := range jsonconf.GetJsonConf().LevelConfig {
		if lv == val.Level {
			return &val
		}
	}
	return nil
}

func GetTaskConfig(taskid int) *jsonconf.AchieveDesc {
	for _, val := range jsonconf.GetJsonConf().TaskConfig {
		if val.Id == taskid {
			return &val
		}
	}
	return nil
}

func GetAchieveConfig(taskid int) *jsonconf.AchieveDesc {
	for _, val := range jsonconf.GetJsonConf().AchieventConfig {
		if val.Id == taskid {
			return &val
		}
	}
	return nil
}

func (uinfo *UserData) CalcTaskList(list *TaskList, uniqueid string) *TaskList {

	newlist := new(TaskList)
	curtype := -1 //记录当前类型

	for k, val := range list.Taskdata {
		//未完成的才做判断
		if val.Taskstatus != 1 {
			continue
		}
		cfg := GetTaskConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcTaskList GetTaskConfig failed id=%v", val.Taskid)
			continue
		}

		if cfg.TaskType == DAILY_TASKTYPE_LOGIN {
			nowloginday := time.Now().Day()
			lasttime := time.Unix(int64(uinfo.LastLoginTime), 0)
			lastloginday := lasttime.Day()

			if nowloginday == lastloginday && val.Taskstatus == 1 {
				list.Taskdata[k].Taskprogress = 1
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_GETGUANCNT {
			list.Taskdata[k].Taskprogress = uinfo.GetFromGuanCnt
			//当日提取存钱罐次数
			if uinfo.GetFromGuanCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_PASSLEVEL {
			list.Taskdata[k].Taskprogress = uinfo.Task.PassLevel
			if uinfo.Task.PassLevel >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_USEITEM {
			list.Taskdata[k].Taskprogress = uinfo.Task.UseItemCnt
			if uinfo.Task.UseItemCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_GETREDBAG {
			list.Taskdata[k].Taskprogress = uinfo.Task.GetRedbagCnt
			if uinfo.Task.GetRedbagCnt >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_GETGUANGOLD {
			list.Taskdata[k].Taskprogress = uinfo.Task.GetGuanGold
			if uinfo.Task.GetGuanGold >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_ONLINEMIN {
			list.Taskdata[k].Taskprogress = uinfo.Task.OnlineMin
			if uinfo.Task.OnlineMin >= cfg.Num {
				list.Taskdata[k].Taskstatus = 2
			}
		} else if cfg.TaskType == DAILY_TASKTYPE_PLAYSMALLGAME {
			list.Taskdata[k].Taskprogress = uinfo.Task.PlaySmall
			if uinfo.Task.PlaySmall > 0 {
				list.Taskdata[k].Taskstatus = 2
			}
		}

	}

	for k, val := range list.Taskdata {

		cfg := GetTaskConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcTaskList GetTaskConfig failed id=%v", val.Taskid)
			continue
		}

		if val.Taskstatus == 2 {
			//未领取已完成 只需要加入第一种
			if curtype == cfg.TaskType {
				continue
			} else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		} else if val.Taskstatus == 1 {
			//未完成 返回第一个
			if curtype == cfg.TaskType {
				continue
			} else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		} else {
			//已领取  需要判断一下是否最后一项
			if k != len(list.Taskdata)-1 {
				//不是最后一条数据
				nextcfg := GetTaskConfig(list.Taskdata[k+1].Taskid)
				if nextcfg != nil {
					if nextcfg.TaskType != cfg.TaskType {
						//下面一天不是此类型了
						newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
						curtype = cfg.TaskType
					}
				}

			} else {
				//最后一条 加入
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		}

	}

	//需要保存到redis
	SaveTaskInfo(uniqueid, 1, list)

	//排序
	sort.Sort(newlist)

	return newlist
}

func (uinfo *UserData) CalcAchieveProgress(ttype int) int {
	rtval := 0
	switch ttype {
	case ACHIEVETYPE_WATCHADDS:
		rtval = uinfo.Achieve.WatchAdsCnt
	case ACHIEVETYPE_USERLV:
		rtval = uinfo.Lv
	case ACHIEVETYPE_KILLSTAR:
		rtval = uinfo.Achieve.KillStar
	case ACHIEVETYPE_GETGUANCNT:
		rtval = uinfo.Achieve.SumGetGuan
	case ACHIEVETYPE_USEITEMCNT:
		rtval = uinfo.Achieve.SumUseItemCnt
	default:
		logger.Error("CalcAchieveProgress type wrong ttype=%v", ttype)
	}

	return rtval
}

//成就返回的是新的成就列表
func (uinfo *UserData) CalcAchieveList(list *TaskList, uniqueid string) *TaskList {
	newlist := new(TaskList)
	curtype := -1 //记录当前类型

	//第一遍首先将所有进度设置为正确的状态
	for k, val := range list.Taskdata {
		cfg := GetAchieveConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcAchieveList GetTaskConfig failed id=%v", val.Taskid)
			continue
		}

		list.Taskdata[k].Taskprogress = uinfo.CalcAchieveProgress(cfg.TaskType)
		if val.Taskstatus == 1 {
			switch cfg.TaskType {
			case ACHIEVETYPE_WATCHADDS:
				if uinfo.Achieve.WatchAdsCnt >= cfg.Num {
					list.Taskdata[k].Taskstatus = 2
				}
			case ACHIEVETYPE_USERLV:
				if uinfo.Lv >= cfg.Num {
					list.Taskdata[k].Taskstatus = 2
				}
			case ACHIEVETYPE_KILLSTAR:
				if uinfo.Achieve.KillStar >= cfg.Num {
					list.Taskdata[k].Taskstatus = 2
				}
			case ACHIEVETYPE_GETGUANCNT:
				if uinfo.Achieve.SumGetGuan >= cfg.Num {
					list.Taskdata[k].Taskstatus = 2
				}
			case ACHIEVETYPE_USEITEMCNT:
				if uinfo.Achieve.SumUseItemCnt >= cfg.Num {
					list.Taskdata[k].Taskstatus = 2
				}
			default:
				logger.Error("CalcAchieveProgress type wrong ttype=%v", cfg.TaskType)
			}
		}

	}

	for k, val := range list.Taskdata {

		cfg := GetAchieveConfig(val.Taskid)
		if cfg == nil {
			logger.Error("CalcAchieveList GetTaskConfig failed id=%v", val.Taskid)
			continue
		}

		if val.Taskstatus == 2 {
			//未领取已完成 只需要加入第一种
			if curtype == cfg.TaskType {
				continue
			} else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		} else if val.Taskstatus == 1 {
			//未完成 返回第一个
			if curtype == cfg.TaskType {
				continue
			} else {
				//将类型加入返回列表
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		} else {
			//已领取  需要判断一下是否最后一项
			if k != len(list.Taskdata)-1 {
				//不是最后一条数据
				nextcfg := GetAchieveConfig(list.Taskdata[k+1].Taskid)
				if nextcfg != nil {
					if nextcfg.TaskType != cfg.TaskType {
						//下面一天不是此类型了
						newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
						curtype = cfg.TaskType
					}
				}

			} else {
				//最后一条 加入
				newlist.Taskdata = append(newlist.Taskdata, list.Taskdata[k])
				curtype = cfg.TaskType
			}
		}

	}

	//保存旧的列表
	SaveTaskInfo(uniqueid, 2, list)

	//将返回的列表排序
	sort.Sort(newlist)
	logger.Info("CalcAchieveList alist=%v", newlist)
	return newlist
}

func SaveTaskInfo(uuid string, tasktype int, list *TaskList) error {
	savestr, err := json.Marshal(list)
	if err != nil {
		logger.Error("SaveTaskInfo err =%v", err)
		return err
	}

	if tasktype == 1 {
		err = redishandler.GetRedisClient().HSet(redis.USER_TASKINFO_LIST, uuid, string(savestr))
	} else if tasktype == 2 {
		err = redishandler.GetRedisClient().HSet(redis.USER_ACHIEVEMENTINFO_LIST, uuid, string(savestr))
		//logger.Info("SaveTaskInfo savestr=%v", string(savestr))
	} else {
		logger.Error("tasktype invalid")
		return errors.New("tasktype invalid")
	}
	return err
}

func GetTaskInfo(uuid int, tasktype int, channel string) (*TaskList, error) {
	unqiueuuid := strconv.Itoa(uuid) + channel
	var data string
	var err error
	if tasktype == 1 {
		data, err = redishandler.GetRedisClient().HGet(redis.USER_TASKINFO_LIST, unqiueuuid)
		//兼容老的数据
		if err != nil {
			//没有读到数据 则去读取一下老的id
			olddata, err := redishandler.GetRedisClient().HGet(redis.USER_TASKINFO_LIST, strconv.Itoa(uuid))
			if err == nil {
				err = redishandler.GetRedisClient().HSet(redis.USER_TASKINFO_LIST, unqiueuuid, olddata)
				if err == nil {
					//删除老的数据 以后都走新的数据
					err = redishandler.GetRedisClient().HDel(redis.USER_TASKINFO_LIST, strconv.Itoa(uuid))
					logger.Info("GetTaskInfo uuid=%v do set", uuid)
				}
				data, err = redishandler.GetRedisClient().HGet(redis.USER_TASKINFO_LIST, unqiueuuid)
			}
		}
	} else if tasktype == 2 {
		data, err = redishandler.GetRedisClient().HGet(redis.USER_ACHIEVEMENTINFO_LIST, unqiueuuid)
		//成就这一块需要兼容老的数据
		if err != nil {
			//没有读到数据 则去读取一下老的id
			olddata, err := redishandler.GetRedisClient().HGet(redis.USER_ACHIEVEMENTINFO_LIST, strconv.Itoa(uuid))
			if err == nil {
				err = redishandler.GetRedisClient().HSet(redis.USER_ACHIEVEMENTINFO_LIST, unqiueuuid, olddata)
				if err == nil {
					//删除老的数据 以后都走新的数据
					err = redishandler.GetRedisClient().HDel(redis.USER_ACHIEVEMENTINFO_LIST, strconv.Itoa(uuid))
					logger.Info("GetTaskInfo uuid=%v do set", uuid)
				}
				data, err = redishandler.GetRedisClient().HGet(redis.USER_ACHIEVEMENTINFO_LIST, unqiueuuid)
			}
		}
	} else {
		logger.Error("tasktype invalid")
		return nil, errors.New("tasktype invalid")
	}

	if err != nil {
		return nil, err
	}

	var list TaskList
	err = json.Unmarshal([]byte(data), &list)
	if err != nil {
		logger.Error("GetTaskInfo err=%v", err)
		return nil, err
	}

	return &list, err
}

//处理领取任务
func (uinfo *UserData) HandleGetTaskReward(req *GettaskrewardReq, resp *GettaskrewardResp, list *TaskList, uuid int) error {
	isfind := false
	index := -1
	var taskdesc *TaskListDesc
	for k, val := range list.Taskdata {
		if val.Taskid == req.Taskid {
			isfind = true
			index = k
			taskdesc = &val
			break
		}
	}

	logger.Info("HandleGetTaskReward index=%v taskdesc=%v", index, taskdesc)
	if isfind && taskdesc != nil && index != -1 {
		if taskdesc.Taskstatus != 2 {
			//状态不是可领取状态 无法领取
			resp.Code = ERROR_TASKCANNOTGET
			resp.Message = "当前任务未完成或已领取"
			return errors.New("当前任务未完成或已领取")
		}

		//状态对的情况 如果是成就下需要判断前置条件是否被
		if req.Tasktype == 2 && index > 0 {
			precfg := GetAchieveConfig(list.Taskdata[index-1].Taskid)
			nowcfg := GetAchieveConfig(taskdesc.Taskid)
			logger.Info("HandleGetTaskRewardGetTaskConfig precfg=%v nowcfg=%v", precfg, nowcfg)
			if precfg != nil && nowcfg != nil && precfg.TaskType == nowcfg.TaskType && list.Taskdata[index-1].Taskstatus != 0 {
				resp.Code = ERROR_TASKPRE_NOTGET
				resp.Message = "前置任务还未领取"
				return errors.New("当前任务未完成或已领取")
			}
		}
	} else {
		resp.Code = ERROR_TASKID_WRONG
		resp.Message = "当前任务id错误"
		return errors.New("当前任务id错误")
	}

	var cfg *jsonconf.AchieveDesc
	if req.Tasktype == 2 {
		cfg = GetAchieveConfig(taskdesc.Taskid)
		if cfg == nil || len(cfg.Reward) < 2 {
			resp.Code = ERROR_SRV_ERROR
			resp.Message = "网络错误"
			return errors.New("获取配置失败")
		}
	} else {
		cfg = GetTaskConfig(taskdesc.Taskid)
		if cfg == nil || len(cfg.Reward) < 2 {
			resp.Code = ERROR_SRV_ERROR
			resp.Message = "网络错误"
			return errors.New("获取配置失败")
		}
	}

	//将状态置位已领取
	list.Taskdata[index].Taskstatus = 0
	//发奖励
	sub := len(cfg.Reward) / 2
	for i := 0; i < sub; i++ {
		rtype := cfg.Reward[i*2]
		rnum := cfg.Reward[i*2+1]
		r1, r2, r3, r4, r5, r6, r7, r8 := uinfo.RewardUser(rtype, rnum, req.Gameid, req.Channel, uuid)
		if resp.Data.Lv != r1 {
			resp.Data.Lv = r1
			resp.Data.Costtime = uinfo.UpLvCostTime / 3600
		}
		resp.Data.Rewardstar += r2
		resp.Data.Chuiitem += r3
		resp.Data.Shuaitem += r4
		resp.Data.Swapitem += r5
		resp.Data.Eliminitem += r6
		resp.Data.Goldnum = r7
		resp.Data.Addgold = r8
	}

	return nil
}

//领取红包 按次数计算
func (uinfo *UserData) FetchRedPacket(gameid string, channel string, uuid int) int {
	uinfo.FetchRedCnt++
	addgold := jsonconf.GetRedpacketNum(uinfo.FetchRedCnt)
	if addgold == 0 {
		logger.Error("FetchRedPacket failed addgold=0")
		return 0
	}

	goldnum, realaddnum, err := AddCoinToSdk(uuid, addgold, gameid, channel, 102)
	if err != nil {
		logger.Error("RewardUser failer err=%v", err)
	}
	uinfo.RealGold = goldnum

	uniqueid := strconv.Itoa(uuid) + channel
	SaveUserInfo(uinfo, uniqueid)
	return realaddnum
}

func (uinfo *UserData) RewardUser(rtype int, num int, gameid string, channel string, uuid int) (int, int, int, int, int, int, int, int) {
	logger.Info("RewardUser rtype=%v,num=%v", rtype, num)
	switch rtype {
	case REWARDTYPE_STAR:
		return 0, num, 0, 0, 0, 0, 0, 0
	case REWARDTYPE_CHUI:
		return 0, 0, num, 0, 0, 0, 0, 0
	case REWARDTYPE_SHUA:
		return 0, 0, 0, num, 0, 0, 0, 0
	case REWARDTYPE_SWAP:
		return 0, 0, 0, 0, num, 0, 0, 0
	case REWARDTYPE_ELIMITE:
		return 0, 0, 0, 0, 0, num, 0, 0
	case REWARDTYPE_EXP:
		isup := uinfo.AddUserExp(num)
		if isup {
			return uinfo.Lv, 0, 0, 0, 0, 0, 0, 0
		} else {
			return 0, 0, 0, 0, 0, 0, 0, 0
		}
	case REWARDTYPE_GOLD:
		/*goldnum, _, err := AddCoinToSdk(uuid, num, gameid, channel, 102)
		if err != nil {
			logger.Error("RewardUser failer err=%v", err)
		}
		uinfo.RealGold = goldnum
		//uinfo.RealGold += num*/
		return 0, 0, 0, 0, 0, 0, 0, 0
	case REWARDTYPE_REDPACKAGE:
		//todo
		//readadd := uinfo.FetchRedPacket(gameid, channel, uuid)
		//return 0, 0, 0, 0, 0, 0, uinfo.RealGold, readadd
		return 0, 0, 0, 0, 0, 0, 0, 0
	default:
		return 0, 0, 0, 0, 0, 0, 0, 0
	}
	return 0, 0, 0, 0, 0, 0, 0, 0
}

func (u *UserData) ReInitWithDraw(uniqueuid string) error {
	//u.WithDraw.Cashdata = u.WithDraw.Cashdata[:0]
	//重新读取配置
	for _, val := range jsonconf.GetJsonConf().WithDrawConfig {

		isin, idx := u.IsInWithList(val.Money)
		if isin && idx >= 0 && idx < len(u.WithDraw.Cashdata) {
			//已经有了的话更新一下配置
			u.WithDraw.Cashdata[idx].Day = val.Day
			u.WithDraw.Cashdata[idx].Limitlv = val.Level
			u.WithDraw.Cashdata[idx].Cnum = val.Money
			u.WithDraw.Cashdata[idx].Cid = val.Id
		} else {
			//还没有 新加入
			var tmp WithDrawDesc
			tmp.Cid = val.Id
			tmp.Cnum = val.Money
			if val.Isnew == 1 {
				tmp.Isnew = 1
			} else {
				tmp.Isnew = 2
			}
			tmp.Limitlv = val.Level
			if val.Id == 1 {
				tmp.Preisfind = 1
			} else {
				tmp.Preisfind = 0
			}
			tmp.Day = val.Day
			u.WithDraw.Cashdata = append(u.WithDraw.Cashdata, tmp)
		}

	}

	//需要反过来判断一下 如果此时提现档位在表里面不存在 则删除
	for i := 0; i < len(u.WithDraw.Cashdata); {
		exist := false
		for _, val := range jsonconf.GetJsonConf().WithDrawConfig {
			if val.Money == u.WithDraw.Cashdata[i].Cnum {
				exist = true
			}
		}

		if !exist {
			u.WithDraw.Cashdata = append(u.WithDraw.Cashdata[:i], u.WithDraw.Cashdata[i+1:]...)
		} else {
			i++
		}
	}

	//需要统一处理一下前置条件
	for i := 0; i < len(u.WithDraw.Cashdata); i++ {
		if i > 0 {
			//需要判断下前面的前置条件
			if u.WithDraw.Cashdata[i-1].Preisfind == 1 {
				//前面已完成，拿自己也变成完成状态
				u.WithDraw.Cashdata[i].Preisfind = 1
			}
		}
	}

	for _, val := range jsonconf.GetJsonConf().ActiveWithdrawConfig {

		isin, idx := u.IsInSpeaialWithList(val.Money)
		if isin && idx >= 0 && idx < len(u.WithDraw.SpecialCashdata) {
			//已经有了的话更新一下配置
			u.WithDraw.SpecialCashdata[idx].Day = val.Day
			u.WithDraw.SpecialCashdata[idx].Limitlv = val.Level
			u.WithDraw.SpecialCashdata[idx].Cnum = val.Money
		} else {
			//还没有 新加入
			var tmp WithDrawDesc
			tmp.Cid = val.Id
			tmp.Cnum = val.Money
			if val.Isnew == 1 {
				tmp.Isnew = 1
			} else {
				tmp.Isnew = 2
			}
			tmp.Limitlv = val.Level
			//没有前置条件
			tmp.Preisfind = 1

			tmp.Day = val.Day
			u.WithDraw.SpecialCashdata = append(u.WithDraw.SpecialCashdata, tmp)
		}

	}

	//做一个排序
	sort.Sort(u.WithDraw.Cashdata)
	sort.Sort(u.WithDraw.SpecialCashdata)

	err := SaveUserInfo(u, uniqueuid)
	if err != nil {
		logger.Error("ReInitWithDraw failed")
	}

	return err
}

func InitUserInfo(data *UserLoginReq, resp *UserLoginResp, uuid int, uniqueuid string) error {

	var initdata UserData
	initdata.Lv = 1
	initdata.LvRewardGet = 2
	initdata.Exp = 0
	initdata.Userid = uuid
	initdata.ContinueLoginDay = 1
	initdata.SumLoginDay = 1
	initdata.GetFromGuanCnt = 0
	initdata.GuanGold = 0
	initdata.LastLoginTime = int(time.Now().Unix())
	goldnum, _ := GetCoinFromSdk(uuid, data.Gameid, data.Channel)
	initdata.RealGold = goldnum
	initdata.WatchAddsTime = WATCH_ADD_DAY_LIMIT
	initdata.LeftFreeRB = FREE_REDBAG_NUM
	initdata.UpLvCostTime = 0
	initdata.UpLvCostTimeSec = int(time.Now().Unix())
	initdata.ShakeTime = SHAKELIMIT
	initdata.IsNew = 1
	initdata.FetchRdBagNum = 0

	for _, val := range jsonconf.GetJsonConf().WithDrawConfig {
		var tmp WithDrawDesc
		tmp.Cid = val.Id
		tmp.Cnum = val.Money
		if val.Isnew == 1 {
			tmp.Isnew = 1
		} else {
			tmp.Isnew = 2
		}
		tmp.Limitlv = val.Level
		if val.Id == 1 {
			tmp.Preisfind = 1
		} else {
			tmp.Preisfind = 0
		}
		tmp.Day = val.Day
		initdata.WithDraw.Cashdata = append(initdata.WithDraw.Cashdata, tmp)
	}
	//处理活跃提现的部分
	for _, val := range jsonconf.GetJsonConf().ActiveWithdrawConfig {
		var tmp WithDrawDesc
		tmp.Cid = val.Id
		tmp.Cnum = val.Money
		if val.Isnew == 1 {
			tmp.Isnew = 1
		} else {
			tmp.Isnew = 2
		}
		tmp.Limitlv = val.Level
		//没有前置条件
		tmp.Preisfind = 1

		tmp.Day = val.Day
		initdata.WithDraw.SpecialCashdata = append(initdata.WithDraw.SpecialCashdata, tmp)
	}

	resp.Data.Guangold = initdata.GuanGold
	resp.Data.Leftredbagcnt = initdata.WatchAddsTime
	resp.Data.Walletgold = initdata.RealGold
	resp.Data.Userlv = initdata.Lv
	resp.Data.Userexp = initdata.Exp
	resp.Data.Sumloginday = initdata.SumLoginDay
	resp.Data.Shakeleftcnt = initdata.ShakeTime
	resp.Data.IsNew = initdata.IsNew

	err := SaveUserInfo(&initdata, uniqueuid)
	logger.Info("InitUserInfoddddd uinfo=%+v", initdata)
	if err != nil {
		logger.Error("InitUserInfo err=%v", err)
		return err
	}

	//初始化一下玩家的任务与成就数据数据
	err = InitTaskAndAchievement(uuid, data.Channel)

	return err
}

func (u *UserData) IsInWithList(num float32) (bool, int) {
	for k, val := range u.WithDraw.Cashdata {
		if val.Cnum == num {
			return true, k
		}
	}
	return false, -1
}

func (u *UserData) IsInSpeaialWithList(num float32) (bool, int) {
	for k, val := range u.WithDraw.SpecialCashdata {
		if val.Cnum == num {
			return true, k
		}
	}
	return false, -1
}

func (t *TaskList) IsInTaskList(id int) bool {
	for _, val := range t.Taskdata {
		if val.Taskid == id {
			return true
		}
	}
	return false
}

func InitTaskAndAchievement(uuid int, channel string) error {
	unqiueid := strconv.Itoa(uuid) + channel
	//先初始化任务
	tlist, err := GetTaskInfo(uuid, 1, channel)
	if tlist == nil {
		tasklist := new(TaskList)
		for _, val := range jsonconf.GetJsonConf().TaskConfig {
			var tmp TaskListDesc
			tmp.Taskstatus = 1
			tmp.Taskid = val.Id
			tmp.Taskprogress = 0
			tasklist.Taskdata = append(tasklist.Taskdata, tmp)
		}

		err := SaveTaskInfo(unqiueid, 1, tasklist)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
			//return err
		}
	} else {
		for _, val := range jsonconf.GetJsonConf().TaskConfig {
			if !tlist.IsInTaskList(val.Id) {
				var tmp TaskListDesc
				tmp.Taskstatus = 1
				tmp.Taskid = val.Id
				tmp.Taskprogress = 0
				tlist.Taskdata = append(tlist.Taskdata, tmp)
			}
		}

		for k, _ := range tlist.Taskdata {
			tlist.Taskdata[k].Taskprogress = 0
			tlist.Taskdata[k].Taskstatus = 1

		}

		err := SaveTaskInfo(unqiueid, 1, tlist)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
			//return err
		}
	}

	//成就
	alist, err := GetTaskInfo(uuid, 2, channel)
	if alist == nil {
		achievelist := new(TaskList)
		for _, val := range jsonconf.GetJsonConf().AchieventConfig {
			var tmp TaskListDesc
			tmp.Taskstatus = 1
			tmp.Taskid = val.Id
			tmp.Taskprogress = 0
			achievelist.Taskdata = append(achievelist.Taskdata, tmp)
		}

		err = SaveTaskInfo(unqiueid, 2, achievelist)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
			return err
		}
	} else {
		for _, val := range jsonconf.GetJsonConf().AchieventConfig {
			if !alist.IsInTaskList(val.Id) {
				var tmp TaskListDesc
				tmp.Taskstatus = 1
				tmp.Taskid = val.Id
				tmp.Taskprogress = 0
				alist.Taskdata = append(alist.Taskdata, tmp)
			}
		}

		err = SaveTaskInfo(unqiueid, 2, alist)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
			return err
		}
	}

	return nil
}

//计算当日可提取次数
func (u *UserData) CalcTotalCnt() int {
	maxtime := 0
	usertime := 0
	for _, val := range jsonconf.GetJsonConf().MoneyBoxTimeConfig {
		if maxtime < val.Times {
			maxtime = val.Times
		}
		if val.Login == u.ContinueLoginDay {
			usertime = val.Times
		}
	}

	if usertime == 0 {
		usertime = maxtime
	}
	return usertime
}

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.Task.GetGuanGold = 0
		u.Task.GetRedbagCnt = 0
		u.Task.OnlineMin = 0
		u.Task.PassLevel = 0
		u.Task.UseItemCnt = 0
		u.Task.PlaySmall = 0
		u.ShakeTime = SHAKELIMIT
		u.FetchRdBagNum = 0

		//任务也需要处理
		/*tasklist, err := GetTaskInfo(u.Userid, 1)
		if err == nil {
			for k, _ := range tasklist.Taskdata {
				tasklist.Taskdata[k].Taskstatus = 1
				tasklist.Taskdata[k].Taskprogress = 0
			}
		} else {
			logger.Error("HandlePassDay GetTaskInfo failer err=%v", err)
		}*/
		/*tasklist := new(TaskList)
		for _, val := range jsonconf.GetJsonConf().TaskConfig {
			var tmp TaskListDesc
			tmp.Taskstatus = 1
			tmp.Taskid = val.Id
			tmp.Taskprogress = 0
			tasklist.Taskdata = append(tasklist.Taskdata, tmp)
		}

		err := SaveTaskInfo(u.Userid, 1, tasklist)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
		}*/
		err := InitTaskAndAchievement(uuid, channel)
		if err != nil {
			logger.Error("InitTaskAndAchievement err=%v", err)
		}

		//签到数据处理
		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 = ERROR_SRV_ERROR
		resp.Message = "ERROR_SRV_ERROR"
		return err
	}

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

	//需要处理下提现表信息
	err = data.ReInitWithDraw(uniqueuid)
	if err != nil {
		logger.Error("GetUserData 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)
	}

	//处理一下领取等级奖励金币
	if data.LvRewardGet == 1 {
		cfg := GetUserLvConfig(data.Lv)
		if cfg != nil {
			gold, _, err := AddCoinToSdk(uuid, cfg.Cash, req.Gameid, req.Channel, 101)
			if err != nil {
				data.RealGold = gold
			} else {
				logger.Error("GetCoinFromSdk err=%v", err)
			}
		}
		data.LvRewardGet = 2

	}

	SaveUserInfo(data, uniqueuid)

	resp.Data.Walletgold = data.RealGold
	resp.Data.Leftredbagcnt = data.WatchAddsTime
	resp.Data.Guangold = data.GuanGold
	resp.Data.Userlv = data.Lv
	resp.Data.Userexp = data.Exp
	resp.Data.Sumloginday = data.SumLoginDay
	resp.Data.Shakeleftcnt = data.ShakeTime
	resp.Data.IsNew = data.IsNew
	return nil
}

//获取提现记录
func GetWithDrawList(uuid int) (*WithDrawList, error) {
	var list *WithDrawList
	list = new(WithDrawList)
	liststr, err := redishandler.GetRedisClient().HGet(redis.USER_WITHDRAW_RECORDLIST, strconv.Itoa(uuid))
	if err != nil {
		return nil, err
	}
	err = json.Unmarshal([]byte(liststr), list)
	if err != nil {
		return nil, err
	}
	return list, nil
}

func (uinfo *UserData) GetSpecialWithDrawData(money float32) (int, *WithDrawDesc) {
	//处理提现状态
	for k, val := range uinfo.WithDraw.SpecialCashdata {
		if val.Cnum == money {
			return k, &val
		}
	}
	return -1, nil
}

func (uinfo *UserData) GetWithDrawData(money float32) (int, *WithDrawDesc) {
	//处理提现状态
	for k, val := range uinfo.WithDraw.Cashdata {
		if val.Cnum == money {
			return k, &val
		}
	}
	return -1, nil
}

//添加提现记录
func AddWithDrawList(uuid int, data *WithDrawRecord) error {
	exist, err := redishandler.GetRedisClient().HExists(redis.USER_WITHDRAW_RECORDLIST, strconv.Itoa(uuid))
	if err != nil {
		return err
	}
	if !exist {
		//添加新的记录
		var tmp WithDrawList
		tmp.Withdata = append(tmp.Withdata, *data)

		savestr, err := json.Marshal(&tmp)
		if err != nil {
			return err
		}
		err = redishandler.GetRedisClient().HSet(redis.USER_WITHDRAW_RECORDLIST, strconv.Itoa(uuid), string(savestr))
		return err
	}

	/*liststr,err := redishandler.GetRedisClient().HGet(redis.USER_WITHDRAW_RECORDLIST,strconv.Itoa(uuid))
	if err != nil {
		return err
	}

	var list WithDrawList
	err = json.Unmarshal([]byte(liststr),&list)
	if err != nil {
		return err
	}*/

	list, err := GetWithDrawList(uuid)
	if err != nil || list == nil {
		logger.Error("AddWithDrawList err=%v", err)
		return err
	}
	list.Withdata = append(list.Withdata, *data)
	savestr, err := json.Marshal(list)
	if err != nil {
		return err
	}
	err = redishandler.GetRedisClient().HSet(redis.USER_WITHDRAW_RECORDLIST, strconv.Itoa(uuid), string(savestr))
	return err

}

//返回是否升级
func (uinfo *UserData) AddUserExp(num int) bool {
	totalexp := num
	isup := false
	for {
		lvcfg := GetUserLvConfig(uinfo.Lv)
		if lvcfg == nil {
			logger.Error("AddUserExp fail lv=%v", uinfo.Lv)
			break
		}
		//判断下是否满级了
		nexcfg := GetUserLvConfig(uinfo.Lv + 1)
		if nexcfg == nil {
			//已经满级了
			uinfo.Exp += totalexp
			break
		}

		//计算一下当前升级需要剩下的

		needexp := lvcfg.Exp - uinfo.Exp
		if totalexp < needexp {
			//不够升级的
			uinfo.Exp += totalexp
			break
		} else {
			//够升级的 升一级
			uinfo.Lv++
			uinfo.LvRewardGet = 1 //当前等级奖励置位可以领取
			isup = true
			totalexp -= needexp
			uinfo.Exp = 0
			logger.Info("TESTSSSSSSSSSSSSS uinfo=%+v", uinfo)
			continue
		}
	}

	if isup {
		uinfo.UpLvCostTime = int(time.Now().Unix()) - uinfo.UpLvCostTimeSec
		if uinfo.UpLvCostTime < 0 {
			uinfo.UpLvCostTime = 0
		}
		uinfo.UpLvCostTimeSec = int(time.Now().Unix())
	}

	logger.Info("AddUserExp:%v,exp=%v", uinfo.Userid, uinfo.Exp)
	return isup
}

func GettotalParam(paramlist []string) string {
	//排序
	sort.Strings(paramlist)

	//拼接
	sumparam := ""
	for _, val := range paramlist {
		sumparam += val
	}

	return sumparam
}

func GetHashValue(signsum string) string {
	/*h := sha1.New()
	h.Write([]byte(signsum))
	bs := h.Sum(nil)
	sign := hex.EncodeToString(bs)*/
	ctx := md5.New()
	ctx.Write([]byte(signsum))
	return hex.EncodeToString(ctx.Sum(nil))
}

func DoHttpPost(bys []byte, apistr string) (string, error) {
	body := bytes.NewBuffer(bys)
	url1 := XIAOXINGXING_SDKURLOFFICAL + apistr //"api/server/addcoin"

	res, err := http.Post(url1, "application/json;charset=utf-8", body)
	if err != nil {
		logger.Error("DoHttpPost failed err=%v", err)
		return "", err
	}
	result, _ := ioutil.ReadAll(res.Body)
	defer res.Body.Close()

	return string(result), nil
}

func GetCoinFromSdk(uuid int, gameid string, channel string) (int, error) {

	SERVERKEY := XIAOXINGXING_SERVERKEYTEST
	if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}

	if gameid == "1016" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1016
	}
	if gameid == "1019" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1019
	}
	if gameid == "1020" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1020
	}
	if gameid == "1021" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1021
	}
	if gameid == "1023" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1023
	}
	if gameid == "1030" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1030
	}
	var paramlist []string
	var params GetCoinDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign
	logger.Info("GetCoinFromSdk sumparam is:%v,sign is:", signsum, sign)

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}
	res, err := DoHttpPost(bys, "api/server/getcoin")
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}

	logger.Info("GetCoinFromSdk res=%v", res)

	var resp AddCoinResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return 0, err
	}

	if resp.Code != "0" {
		logger.Error("GetCoinFromSdk failed=%v", resp.Msg)
		return 0, err
	}

	return resp.Data.Mycoin, nil
}

func AddCoinToSdk(uuid int, goldnum int, gameid string, channel string, atype int) (int, int, error) {
	//处理一下实际增加值
	realaddgoldnum := goldnum
	newnum, err := GetCoinFromSdk(uuid, gameid, channel)
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, 0, err
	}

	if newnum >= 950000 {
		realaddgoldnum = 1
	}

	SERVERKEY := XIAOXINGXING_SERVERKEYTEST
	if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}
	if gameid == "1016" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1016
	}
	if gameid == "1019" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1019
	}
	if gameid == "1020" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1020
	}
	if gameid == "1021" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1021
	}
	if gameid == "1023" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1023
	}
	if gameid == "1030" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1030
	}
	var paramlist []string
	sign_type := "sign_type=md5"
	paramlist = append(paramlist, sign_type)
	time_stamp := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramlist = append(paramlist, time_stamp)
	paramgameid := "gameid=" + gameid
	paramlist = append(paramlist, paramgameid)
	pchannel := "channel=" + channel
	paramlist = append(paramlist, pchannel)
	puid := "uid=" + strconv.Itoa(uuid)
	paramlist = append(paramlist, puid)
	pcoin := "coin=" + strconv.Itoa(realaddgoldnum)
	paramlist = append(paramlist, pcoin)
	ptyp := "typ=" + strconv.Itoa(atype)
	paramlist = append(paramlist, ptyp)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY
	logger.Info("AddCoinToSdk sumparam=%v", signsum)

	//进行hash
	sign := GetHashValue(signsum)

	var req AddCoinDesc
	req.Channel = channel
	req.Gameid = gameid
	req.Coin = realaddgoldnum
	req.Sign = sign
	req.Sign_type = "md5"
	req.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	req.Typ = atype
	req.Uid = uuid

	bys, err := json.Marshal(&req)
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, realaddgoldnum, err
	}
	res, err := DoHttpPost(bys, "api/server/addcoin")
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, realaddgoldnum, err
	}

	logger.Info("AddCoinToSdk res=%v", res)
	var resp AddCoinResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("AddCoinToSdk failed=%v", err)
		return 0, realaddgoldnum, err
	}

	if resp.Code != "0" {
		gold, _ := GetCoinFromSdk(uuid, gameid, channel)
		logger.Error("AddCoinToSdk failed=%v", resp.Msg)
		return gold, realaddgoldnum, err
	}
	return resp.Data.Mycoin, realaddgoldnum, nil
}

func GetCashWechatFromSDK(uuid int, goldnum int, gameid, channel, openid, nickname, headurl, ver string, checkcoin int) (string, error) {

	SERVERKEY := XIAOXINGXING_SERVERKEYTEST
	if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}

	if gameid == "1016" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1016
	}
	if gameid == "1019" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1019
	}
	if gameid == "1020" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1020
	}
	if gameid == "1021" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1021
	}
	if gameid == "1023" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1023
	}
	if gameid == "1030" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1030
	}
	if goldnum == 0 || uuid == 0 || gameid == "" || channel == "" || ver == "" {
		logger.Error("GetCashFromSDK param empty")
		return "error", errors.New("param empty")
	}

	if openid == "" {
		openid = "test"
	}
	var paramlist []string
	var params TixianDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	params.Headurl = headurl
	params.Money = goldnum
	params.Openid = openid
	params.Nickname = nickname
	params.Typ = 11
	params.Ver = ver
	params.Editcoin = 1
	params.Checkcoin = checkcoin
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	phead := "headurl=" + headurl
	pnickname := "nickname=" + nickname
	popenid := "openid=" + openid
	pmoney := "money=" + strconv.Itoa(goldnum)
	ptype := "typ=" + "11" //微信
	ped := "editcoin=1"
	pcheco := "checkcoin=" + strconv.Itoa(checkcoin)
	//pver := "ver=" + params.Ver
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)
	if headurl != "" {
		paramlist = append(paramlist, phead)
	}
	if nickname != "" {
		paramlist = append(paramlist, pnickname)
	}
	paramlist = append(paramlist, popenid)
	paramlist = append(paramlist, pmoney)
	paramlist = append(paramlist, ptype)
	paramlist = append(paramlist, ped)
	paramlist = append(paramlist, pcheco)
	//paramlist = append(paramlist, pver)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCashWechatFromSDK failed=%v", err)
		return "error", err
	}
	res, err := DoHttpPost(bys, "api/server/tixiancdkey")
	logger.Info("GetCashWechatFromSDK sumparam is:%v,sign is:%v", signsum, sign)
	logger.Info("GetCashWechatFromSDK sumparam param=%v", string(bys))
	if err != nil {
		logger.Error("GetCashWechatFromSDK failed=%v", err)
		return "error", err
	}

	logger.Info("GetCashWechatFromSDK res=%v", res)

	var resp GetCashWechatResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCashWechatFromSDK failed=%v", err)
		return "error", err
	}

	if resp.Code != "0" {
		logger.Error("GetCashWechatFromSDK failed=%v", resp.Msg)
		return "error", errors.New(resp.Msg)
	}

	return resp.Data.Cdkey, nil
}

func GetCashFromSDK(uuid int, goldnum int, gameid, channel, openid, nickname, headurl, ver string, checkcoin int) (int, error) {

	SERVERKEY := XIAOXINGXING_SERVERKEYTEST
	if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}

	if gameid == "1016" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1016
	}
	if gameid == "1019" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1019
	}
	if gameid == "1020" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1020
	}
	if gameid == "1021" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1021
	}
	if gameid == "1023" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1023
	}
	if gameid == "1030" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1030
	}
	if goldnum == 0 || uuid == 0 || gameid == "" || channel == "" || openid == "" || ver == "" {
		logger.Error("GetCashFromSDK param empty")
		return 0, errors.New("param empty")
	}
	var paramlist []string
	var params TixianDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	params.Headurl = headurl
	params.Money = goldnum
	params.Openid = openid
	params.Nickname = nickname
	params.Typ = 6
	params.Ver = ver
	params.Editcoin = 1
	params.Checkcoin = checkcoin
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	phead := "headurl=" + headurl
	pnickname := "nickname=" + nickname
	popenid := "openid=" + openid
	pmoney := "money=" + strconv.Itoa(goldnum)
	ptype := "typ=" + "6" //微信
	ped := "editcoin=1"
	pcheco := "checkcoin=" + strconv.Itoa(checkcoin)
	//pver := "ver=" + params.Ver
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)
	if headurl != "" {
		paramlist = append(paramlist, phead)
	}
	if nickname != "" {
		paramlist = append(paramlist, pnickname)
	}
	paramlist = append(paramlist, popenid)
	paramlist = append(paramlist, pmoney)
	paramlist = append(paramlist, ptype)
	paramlist = append(paramlist, ped)
	paramlist = append(paramlist, pcheco)
	//paramlist = append(paramlist, pver)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}
	res, err := DoHttpPost(bys, "api/server/tixian")
	logger.Info("GetCashFromSDK sumparam is:%v,sign is:%v", signsum, sign)
	logger.Info("GetCashFromSDK sumparam param=%v", string(bys))
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}

	logger.Info("GetCashFromSDK res=%v", res)

	var resp GetCashResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}

	if resp.Code != "0" {
		logger.Error("GetCashFromSDK failed=%v", resp.Msg)
		return 0, errors.New(resp.Msg)
	}

	//拉取一下新的金币值
	newnum, err := GetCoinFromSdk(uuid, gameid, channel)
	if err != nil {
		logger.Error("GetCashFromSDK failed=%v", err)
		return 0, err
	}
	return newnum, nil
}

func GetCashList(uuid int, gameid string, channel string, start int, number int) (*[]WithDrawRecord, error) {
	SERVERKEY := XIAOXINGXING_SERVERKEYTEST
	if gameid == "1015" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1015
	}

	if gameid == "1016" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1016
	}
	if gameid == "1019" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1019
	}
	if gameid == "1020" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1020
	}
	if gameid == "1021" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1021
	}
	if gameid == "1023" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1023
	}
	if gameid == "1030" {
		SERVERKEY = XIAOXINGXING_SERVERKEYTEST_1030
	}
	var paramlist []string
	var params GetCashListDesc
	params.Sign_type = "md5"
	params.Gameid = gameid
	params.Channel = channel
	params.Uid = uuid
	params.Time_stamp = strconv.Itoa(int(time.Now().Unix()))
	params.Start = start
	params.Number = number
	signtypestr := "sign_type=" + params.Sign_type
	timestampstr := "time_stamp=" + strconv.Itoa(int(time.Now().Unix()))
	paramgameid := "gameid=" + gameid
	pchannel := "channel=" + channel
	puid := "uid=" + strconv.Itoa(uuid)
	pstart := "start=" + strconv.Itoa(start)
	pnumber := "number=" + strconv.Itoa(number)
	paramlist = append(paramlist, signtypestr)
	paramlist = append(paramlist, timestampstr)
	paramlist = append(paramlist, paramgameid)
	paramlist = append(paramlist, pchannel)
	paramlist = append(paramlist, puid)
	if start != 0 {
		paramlist = append(paramlist, pstart)
	}

	paramlist = append(paramlist, pnumber)

	sumparam := GettotalParam(paramlist)
	//加serverkey
	signsum := sumparam + SERVERKEY
	logger.Info("GetCashList sumparam=%v", signsum)

	//进行hash
	sign := GetHashValue(signsum)
	params.Sign = sign

	bys, err := json.Marshal(&params)
	if err != nil {
		logger.Error("GetCashList failed=%v", err)
		return nil, err
	}
	res, err := DoHttpPost(bys, "api/server/tixian/lst")
	if err != nil {
		logger.Error("GetCashList failed=%v", err)
		return nil, err
	}

	logger.Info("GetCashList res=%v", res)

	var resp GetCashListResp
	err = json.Unmarshal([]byte(res), &resp)
	if err != nil {
		logger.Error("GetCoinFromSdk failed=%v", err)
		return nil, err
	}

	if resp.Code != "0" {
		logger.Error("GetCoinFromSdk failed=%v", resp.Msg)
		return nil, err
	}
	return &resp.Data, nil
}