package logic

import (
	"HttpServer/redishandler"
	"bytes"
	"common/beegomap"
	"common/logger"
	"common/redis"
	ksuid "github.com/segmentio"
	"io/ioutil"
	"mysql"
	"strconv"

	"encoding/json"
	"fmt"
	"net/http"

	"time"
)

var (
	m_userInfo *beegomap.BeeMap //make(map[int32]*UserData
)

func init() {
	m_userInfo = beegomap.NewBeeMap()
}

func InitUserExt(req *UserLoginReq, resp *UserLoginResp, uuid int) {
	var extdata UserExtData
	extdata.User_id = uuid
	extdata.Lv = 1
	extdata.Bean = 0
	extdata.Coin = 0
	extdata.Exp = 0
	extdata.Hot = 0
	extdata.Invite_uid = req.User_invite_uid
	extdata.LoveExp = 0
	extdata.Reg_time = int(time.Now().Unix())
	extdata.ShopNum = 0
	extdata.User_channel = req.Channel_id
	extdata.User_is_black = 0
	extdata.User_reg_time = int(time.Now().Unix())
	extdata.User_scene = req.Scene
	resp.Result.Data.Extdata = extdata
	//保存
	udata := new(UserData)
	udata.Scene = extdata.User_scene
	udata.Hot = extdata.Hot
	udata.Exp = extdata.Exp
	udata.Coin = extdata.Coin
	udata.Bean = extdata.Bean
	udata.Lv = extdata.Lv
	udata.Channel = extdata.User_channel
	udata.InviteUid = extdata.Invite_uid
	udata.Isblack = extdata.User_is_black
	udata.Loevexp = extdata.LoveExp
	udata.Regtime = extdata.Reg_time
	udata.Shopnum = extdata.ShopNum
	udata.Userid = extdata.User_id
	udata.UserInviteId = extdata.User_invite_uid
	udata.Userregtime = extdata.User_reg_time
	udata.LoginTime = int(time.Now().Unix())
	udata.LoginDay = 1

	SaveUserExt(udata)
}

func InitAccountLogin(account string) {
	//首先生成token
	newToken := ksuid.New().String()
	//保存token与account的关系
	SaveAccountToken(account, newToken)
	//首先生成user_base_data
	var basedata UserBaseData
	basedata.User_id = GetNewUUid()
	basedata.User_avatar_url = ""
	basedata.User_city = "天堂"
	basedata.User_gender = 1
	basedata.User_nickname = "游客" + string(basedata.User_id)
	basedata.User_openid = ""
	basedata.User_token = newToken
	//保存base data
	basic, _ := json.Marshal(&basedata)
	SaveUserBasic(basedata.User_id, string(basic))

	SetTouristUid(newToken, basedata.User_id)
	//然后生成user_ext_data
	var extdata UserExtData
	extdata.User_id = basedata.User_id
	extdata.Lv = 1
	extdata.Bean = 0
	extdata.Coin = 0
	extdata.Exp = 0
	extdata.Hot = 0
	extdata.Invite_uid = 0
	extdata.LoveExp = 0
	extdata.Reg_time = int(time.Now().Unix())
	extdata.ShopNum = 0
	extdata.User_channel = 0
	extdata.User_is_black = 0
	extdata.User_reg_time = int(time.Now().Unix())
	extdata.User_scene = 0
	udata := new(UserData)
	udata.Scene = extdata.User_scene
	udata.Hot = extdata.Hot
	udata.Exp = extdata.Exp
	udata.Coin = extdata.Coin
	udata.Bean = extdata.Bean
	udata.Lv = extdata.Lv
	udata.Channel = extdata.User_channel
	udata.InviteUid = extdata.Invite_uid
	udata.Isblack = extdata.User_is_black
	udata.Loevexp = extdata.LoveExp
	udata.Regtime = extdata.Reg_time
	udata.Shopnum = extdata.ShopNum
	udata.Userid = extdata.User_id
	udata.UserInviteId = extdata.User_invite_uid
	udata.Userregtime = extdata.User_reg_time
	udata.LoginTime = int(time.Now().Unix())
	udata.LoginDay = 1

	SaveUserExt(udata)
}

func InitTourist(req *UserLoginReq, resp *UserLoginResp) {
	//首先生成user_base_data
	var basedata UserBaseData
	basedata.User_id = GetNewUUid()
	basedata.User_avatar_url = ""
	basedata.User_city = "天堂"
	basedata.User_gender = 1
	basedata.User_nickname = "游客" + string(basedata.User_id)
	basedata.User_openid = ""
	basedata.User_token = req.Token
	resp.Result.Data.Dasedata = basedata
	//保存base data
	basic, _ := json.Marshal(&basedata)
	SaveUserBasic(basedata.User_id, string(basic))

	SetTouristUid(req.Token, basedata.User_id)
	//然后生成user_ext_data
	InitUserExt(req, resp, basedata.User_id)

}

//微信登录账户初始化
func InitWeChatUser(req *WechatLoginReq, resp *UserLoginResp, uinfo *WxUserInfo) {
	//首先生成user_base_data
	var basedata UserBaseData
	basedata.User_id = GetNewUUid()
	basedata.User_avatar_url = uinfo.AvatarURL
	basedata.User_city = uinfo.City
	basedata.User_gender = uinfo.Gender
	basedata.User_nickname = uinfo.NickName
	basedata.User_openid = uinfo.OpenID
	basedata.User_token = req.Token
	resp.Result.Data.Dasedata = basedata
	//保存base data
	basic, _ := json.Marshal(&basedata)
	SaveUserBasic(basedata.User_id, string(basic))

	SetTouristUid(uinfo.OpenID, basedata.User_id)
	//然后生成user_ext_data
	var extdata UserExtData
	extdata.User_id = basedata.User_id
	extdata.Lv = 1
	extdata.Bean = 0
	extdata.Coin = 0
	extdata.Exp = 0
	extdata.Hot = 0
	extdata.Invite_uid = req.User_invite_uid
	extdata.LoveExp = 0
	extdata.Reg_time = int(time.Now().Unix())
	extdata.ShopNum = 0
	extdata.User_channel = req.Channel_id
	extdata.User_is_black = 0
	extdata.User_reg_time = int(time.Now().Unix())
	extdata.User_scene = 0
	resp.Result.Data.Extdata = extdata
	//保存
	udata := new(UserData)
	udata.Scene = extdata.User_scene
	udata.Hot = extdata.Hot
	udata.Exp = extdata.Exp
	udata.Coin = extdata.Coin
	udata.Bean = extdata.Bean
	udata.Lv = extdata.Lv
	udata.Channel = extdata.User_channel
	udata.InviteUid = extdata.Invite_uid
	udata.Isblack = extdata.User_is_black
	udata.Loevexp = extdata.LoveExp
	udata.Regtime = extdata.Reg_time
	udata.Shopnum = extdata.ShopNum
	udata.Userid = extdata.User_id
	udata.UserInviteId = extdata.User_invite_uid
	udata.Userregtime = extdata.User_reg_time
	udata.LoginTime = int(time.Now().Unix())
	udata.LoginDay = 1

	SaveUserExt(udata)

}

//处理登陆数据
func HandleLoginTime(ext *UserData) {
	ext.LoginTime = int(time.Now().Unix())
	timeStr := time.Now().Format("2006-01-02")
	t, _ := time.Parse("2006-01-02", timeStr)
	timeNumber := int(t.Unix() - 8*3600)
	if timeNumber <= ext.LoginTime {
		ext.LoginDay += 1
	}
}

func TransmitUserData(in *UserData, out *UserExtData) {
	out.LoveExp = in.Loevexp
	out.User_id = in.Userid
	out.ShopNum = in.Shopnum
	out.Exp = in.Exp
	out.Lv = in.Lv
	out.Reg_time = in.Regtime
	out.Coin = in.Coin
	out.Bean = in.Bean
	out.Hot = in.Hot
	out.User_reg_time = in.Userregtime
	out.User_invite_uid = in.UserInviteId
	out.User_is_black = in.Isblack
	out.User_scene = in.Scene
	out.User_channel = in.Channel
	out.Invite_uid = in.InviteUid
}

func HandleQueryInvite(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp QueryInviteResp
	resp.Status = "true"
	var rdata QueryInviteReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleQueryInvite json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		inlist, err := mysql.QueryInvite(rdata.Uuid)
		if err != nil {
			logger.Error("HandleQueryInvite QueryInvite failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			//resp.Message = "QueryInvite failed"
			break
		}

		for _, val := range inlist {
			var tmp QueryInviteData
			tmp.Uuid = val.Uuid
			tmp.Nickname = val.NickName
			tmp.Isfetched = val.IsFecthed
			tmp.Headurl = val.HeadUrl
			resp.Result.Data.Invite_data = append(resp.Result.Data.Invite_data, tmp)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleDoChat(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp DoChatResp
	resp.Status = "true"
	var rdata DoChatReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleDoChat json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		//需要验证敏感词
		msgtoken := GetAccessToken()
		msgurl := URL_WEIXINMSG_CHECK + "?access_token=" + msgtoken
		var check MsgCheckDesc
		check.Content = rdata.Message
		bys, err := json.Marshal(&check)
		if err != nil {
			logger.Error("HandleDoChat json failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		body := bytes.NewBuffer(bys)
		res, err := http.Post(msgurl, "application/json;charset=utf-8", body)
		if err != nil {
			logger.Error(" HandleDoChat ERROR_HTTPPOSTFAILED err=%v", err)
			resp.Result.Code = ERROR_HTTPPOSTFAILED
			return
		}

		result, _ := ioutil.ReadAll(res.Body)
		defer res.Body.Close()

		var msgresp MsgCheckResp
		_ = json.Unmarshal(result, &msgresp)

		if msgresp.Errcode != 0 {
			resp.Result.Code = msgresp.Errcode
			resp.Result.Data = msgresp.Errmsg
			break
		}

		if rdata.Ctype == 0 {
			resp.Result.Code, resp.Result.Data = WorldChat(rdata.Message, rdata.Uuid)
		} else if rdata.Ctype == 1 {
			resp.Result.Code, resp.Result.Data = TeamChat(rdata.Message, rdata.Uuid)
		} else if rdata.Ctype == 2 {
			resp.Result.Code, resp.Result.Data = PrivateChat(rdata.Message, rdata.Uuid, rdata.Taruuid)
		} else {
			logger.Error("HandleDoChat failed err ctypr")
			resp.Result.Code = ERROR_CHATPARAMFAILED
			resp.Result.Data = "ctypr failed"
			break
		}
		break
	}

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

func HandleUnlockEmj(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp UnlockEmjResp
	resp.Status = "true"
	var rdata UnlockEmjReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleUnlockEmj json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		if rdata.Pos < 0 {
			logger.Error("HandleUnlockEmj param failed=%v", rdata)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		emjs := GetChatEmojInfo(rdata.Uuid)
		if emjs == nil {
			logger.Error("HandleUnlockEmj redis failed=%v", rdata)
			resp.Result.Code = ERROR_GETUSERMAPBYUIDFAILED
			break
		}

		if rdata.Pos > len(emjs.Emojinfo)-1 {
			logger.Error("HandleUnlockEmj param failed=%v", rdata)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		emjs.Emojinfo[rdata.Pos] = 1
		err = SaveChatEmojInfo(rdata.Uuid, emjs)
		if err != nil {
			logger.Error("HandleUnlockEmj redis failed=%v", rdata)
			resp.Result.Code = ERROR_GETUSERMAPBYUIDFAILED
			break
		}
		resp.Result.Data.Emjinfo = append(resp.Result.Data.Emjinfo, emjs.Emojinfo...)
		break
	}

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

func HandlequeryChatMessage(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp QueryChatMessageResp
	resp.Status = "true"
	var rdata QueryChatMessageReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlequeryChatMessage json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		if rdata.Ctype == 2 && rdata.Taruuid == 0 {
			logger.Error("HandlequeryChatMessage param failed=%v", rdata)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		if rdata.Ctype == 0 {
			//世界频道
			worlds := GetWorldChatMessage(rdata.Uuid)
			resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, worlds...)
		} else if rdata.Ctype == 1 {
			teams := GetTeamChatMessage(rdata.Uuid)
			resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, teams...)
		} else if rdata.Ctype == 2 {
			privates := GetPrivateChatMessage(rdata.Uuid, rdata.Taruuid)
			resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, privates...)
		} else {
			logger.Error("HandlequeryChatMessage ctype failed %v", rdata)
			resp.Result.Code = ERROR_CHATPARAMFAILED
			break
		}

		break
	}

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

func HandlequeryBrifeMessage(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp QueryBrifeMessageResp
	resp.Status = "true"
	var rdata QueryBrifeMessageReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlequeryBrifeMessage json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		//先查询表情信息
		emjs := GetChatEmojInfo(rdata.Uuid)
		if emjs != nil {
			resp.Result.Data.Emojinfo = append(resp.Result.Data.Emojinfo, emjs.Emojinfo...)
		}

		//世界频道
		var world QueryBrifeMessageData
		world.Isnew = 0
		world.Ctype = 0
		resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, world)

		//工会频道
		var team QueryBrifeMessageData
		team.Ctype = 1
		team.Isnew = 0
		teamnew, err := CheckTeamHasNewMessage(rdata.Uuid)
		if err == nil && teamnew {
			team.Isnew = 1
		}
		resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, team)

		//私人频道
		//优先加入有新消息的
		privatebrief := GetPrivateBriefList(rdata.Uuid)
		resp.Result.Data.Channelinfo = append(resp.Result.Data.Channelinfo, privatebrief...)
		break
	}

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

func HandlequeryNewMessage(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp QueryNewMessageResp
	resp.Status = "true"
	resp.Result.Data.Isnew = 0
	var rdata QueryNewMessageReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlequeryNewMessage json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}
		//先从缓存取，如果已经有新消息则直接返回
		exist, err := redishandler.GetRedisClient().HExists(redis.USER_CHAT_ISNEW, strconv.Itoa(rdata.Uuid))
		if err != nil {
			logger.Error("HandlequeryNewMessage save failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data.Isnew = 0
			break
		}

		if exist {
			resp.Result.Data.Isnew = 1
			break
		}

		//如果没有 则进行判断
		isnew, err := CheckHasNewMessage(rdata.Uuid)
		if err != nil {
			logger.Error("HandlequeryNewMessage CheckHasNewMessage failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data.Isnew = 0
			break
		}

		if isnew {
			resp.Result.Data.Isnew = 1
		}

		break
	}

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

func HandleNewSaveData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SaveDataBackupResp
	resp.Status = "true"
	var rdata SaveDataBackupReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleNewSaveData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			resp.Result.Data = "json unmarshal failed"
			break
		}

		//
		rkey := redis.USER_NEW_DATA_KEY + strconv.Itoa(rdata.Uuid)
		val, err := redishandler.GetRedisClient().GetString(rkey)
		if err != nil {
			//如果没有 直接保存即可
			var tmp1 GetDataSaveDesc
			tmp1.Data_uid = strconv.Itoa(rdata.Uuid)
			tmp1.Data_value = rdata.Value
			savestr, err := json.Marshal(&tmp1)
			if err != nil {
				logger.Error("HandleNewSaveData failed7,err=%v", err)
				resp.Result.Code = ERROR_SRVDB_FAILED
				resp.Result.Data = "ERROR_SRVDB_FAILED"
				break
			}
			err = redishandler.GetRedisClient().SetString(rkey, string(savestr))
			if err != nil {
				logger.Error("HandleNewSaveData failed7,err=%v", err)
				resp.Result.Code = ERROR_SRVDB_FAILED
				resp.Result.Data = "ERROR_SRVDB_FAILED"
				break
			}
			/*rkey1 := "cat:cafe:data:where:data_uid:" + strconv.Itoa(rdata.Uuid)
			val,err = redishandler.GetRedisClient().GetString(rkey1)
			if err != nil {
				logger.Error("HandleNewSaveData ERROR_SRVDB_FAILED failed=%v,val=%v", err,val)
				resp.Result.Code = ERROR_SRVDB_FAILED
				resp.Result.Data = "get redis failed"
				break
			}


			//保存到新的key
			err = redishandler.GetRedisClient().SetString(rkey,val)
			if err !=nil {
				logger.Error("HandleNewSaveData err=%v",err)
			}

			//break*/
		}
		val, _ = redishandler.GetRedisClient().GetString(rkey)
		var final GetDataSaveDesc
		err = json.Unmarshal([]byte(val), &final)
		if err != nil {
			logger.Error("HandleNewGetData failed9,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}
		val = final.Data_value

		//解析val json
		m1 := make(map[string]interface{})
		err = json.Unmarshal([]byte(val), &m1)
		if err != nil {
			logger.Error("HandleNewSaveData failed1,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "json unmarsha failed"
			break
		}
		m2 := make(map[string]interface{})
		err = json.Unmarshal([]byte(rdata.Value), &m2)
		if err != nil {
			logger.Error("HandleNewSaveData failed1,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "json unmarsha failed"
			break
		}

		//比较猫数据
		catmap1 := m1["catData"].(map[string]interface{})
		catmap2 := m2["catData"].(map[string]interface{})
		//logger.Info("HandleNewSaveData catmap1=%v", catmap1)
		//	logger.Info("HandleNewSaveData catmap2=%v", catmap2)
		if len(catmap2) < len(catmap1) {
			logger.Error("HandleNewSaveData failed1,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}
		for k, vak := range catmap2 {
			if catmap1[k] != nil {
				//需要比较等级
				c2 := vak.(map[string]interface{})
				c1 := catmap1[k].(map[string]interface{})
				if c1["level"] != nil && c2["level"] != nil {
					//logger.Info("HandleNewSaveData c1=%v c2=%v", c1["level"], c2["level"])
					if c2["level"].(float64) < c1["level"].(float64) {
						logger.Error("HandleNewSaveData failed2,err=%v", err)
						resp.Result.Code = ERROR_SRVDB_FAILED
						resp.Result.Data = "ERROR_SRVDB_FAILED"
						break
					}
				} else {
					logger.Error("HandleNewSaveData failed11,k=%v", k)
				}
			} else {
				//logger.Error("HandleNewSaveData failed10,k=%v",k)
			}
		}

		//比较roomData
		roommap1 := m1["roomData"].(map[string]interface{})
		roommap2 := m2["roomData"].(map[string]interface{})
		//		logger.Info("HandleNewSaveData catmap1=%v", roommap1)
		//		logger.Info("HandleNewSaveData catmap2=%v", roommap2)
		if len(roommap2) < len(roommap1) {
			logger.Error("HandleNewSaveData failed3,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}
		for k, val := range roommap2 {
			if roommap1[k] != nil {
				r2 := val.(map[string]interface{})
				r1 := roommap1[k].(map[string]interface{})
				//比较unlockId,不做验证
				/*rr2 := r2["unlockId"].([]interface {})
				rr1 := r1["unlockId"].([]interface {})
				if len(rr2) < len(rr1) {
					logger.Error("HandleNewSaveData failed4,err=%v", err)
					resp.Result.Code = ERROR_SRVDB_FAILED
					resp.Result.Data = "ERROR_SRVDB_FAILED"
					break
				}*/

				//比较furnitData
				rrr2 := r2["furnitData"].(map[string]interface{})
				rrr1 := r1["furnitData"].(map[string]interface{})
				if len(rrr2) < len(rrr1) {
					logger.Error("HandleNewSaveData failed5,err=%v", err)
					resp.Result.Code = ERROR_SRVDB_FAILED
					resp.Result.Data = "ERROR_SRVDB_FAILED"
					break
				}

				for k, _ := range rrr2 {
					if rrr1[k] != nil {
						ddtr2 := rrr2[k].(map[string]interface{})
						ddtr1 := rrr1[k].(map[string]interface{})
						if ddtr2["state"] != nil && ddtr1["state"] != nil {
							if ddtr2["state"].(float64) < ddtr1["state"].(float64) {
								logger.Error("HandleNewSaveData failed15,d2=%v,d1=%v", ddtr2["state"].(float64), ddtr1["state"].(float64))
								resp.Result.Code = ERROR_SRVDB_FAILED
								resp.Result.Data = "ERROR_SRVDB_FAILED"
								break
							} else {
								//logger.Error("HandleNewSaveData failed17,d2=%v,d1=%v", ddtr2["state"].(float64), ddtr1["state"].(float64))
							}
						} else {
							logger.Error("HandleNewSaveData failed18,d2=%v,d1=%v", ddtr2["state"].(float64), ddtr1["state"].(float64))
						}

					} else {
						//logger.Error("HandleNewSaveData failed16,k", k)
					}
				}
			}
		}

		//coffeeData
		coffmap1 := m1["coffeeData"].(map[string]interface{})
		coffmap2 := m2["coffeeData"].(map[string]interface{})
		cdmap1 := coffmap1["datas"].(map[string]interface{})
		cdmap2 := coffmap2["datas"].(map[string]interface{})
		if len(cdmap2) < len(cdmap1) {
			logger.Error("HandleNewSaveData failed6,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}

		//签到数据校验
		issign1, ok1 := m1["isSign"].(bool)
		issign2, ok2 := m2["isSign"].(bool)
		if ok1 && ok2 {
			if !issign2 && issign1 {
				//无需验证
				/*logger.Error("HandleNewSaveData failed30,err=%v", err)
				resp.Result.Code = ERROR_SRVDB_FAILED
				resp.Result.Data = "ERROR_SRVDB_FAILED"
				break*/
			}
		}

		signNowLoop1, ok1 := m1["signNowLoop"].(float64)
		signNowLoop2, ok2 := m2["signNowLoop"].(float64)
		signLoopId1, ok3 := m2["signLoopId"].(float64)
		signLoopId2, ok4 := m2["signLoopId"].(float64)
		if ok1 && ok2 && ok3 && ok4 {
			if signLoopId2 < signLoopId1 {
				logger.Error("HandleNewSaveData failed31,err=%v", err)
				resp.Result.Code = ERROR_SRVDB_FAILED
				resp.Result.Data = "ERROR_SRVDB_FAILED"
				break
			}

			if signLoopId1 == signLoopId2 {
				if signNowLoop2 < signNowLoop1 {
					//无需验证
					/*logger.Error("HandleNewSaveData failed33,err=%v", err)
					resp.Result.Code = ERROR_SRVDB_FAILED
					resp.Result.Data = "ERROR_SRVDB_FAILED"
					break*/
				}
			}
		}

		//全部校验过后
		var tmp GetDataSaveDesc
		tmp.Data_uid = strconv.Itoa(rdata.Uuid)
		tmp.Data_value = rdata.Value
		savestr, err := json.Marshal(&tmp)
		if err != nil {
			logger.Error("HandleNewSaveData failed7,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}
		err = redishandler.GetRedisClient().SetString(rkey, string(savestr))
		if err != nil {
			logger.Error("HandleNewSaveData failed7,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleSaveDataBackup(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SaveDataBackupResp
	resp.Status = "true"
	var rdata SaveDataBackupReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleQueryInviteWork json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			resp.Result.Data = "json unmarshal failed"
			break
		}

		err = redishandler.GetRedisClient().HSet(redis.USER_BACKUP_DATA, strconv.Itoa(rdata.Uuid), rdata.Value)
		if err != nil {
			logger.Error("HandleQueryInviteWork save failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			resp.Result.Data = "ERROR_SRVDB_FAILED"
			break
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleNewGetData(w http.ResponseWriter, data string) {
	var resp GetDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleNewGetData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		isfind := false
		//先去取出新的数据
		rkey := redis.USER_NEW_DATA_KEY + strconv.Itoa(rdata.Uuid)

		val, err := redishandler.GetRedisClient().GetString(rkey)
		if err != nil {
			logger.Error("HandleNewGetData err=%v", err)
			//如果不存在数据则去老的取
			rkey1 := "cat:cafe:data:where:data_uid:" + strconv.Itoa(rdata.Uuid)
			val, err = redishandler.GetRedisClient().GetString(rkey1)
			if err != nil {
				resp.Result.Data.Base_data = "{}"
				//resp.Result.Code = ERROR_JSONUNMASHFAILED
				break
			}
			isfind = true
		}

		var final GetDataSaveDesc
		err = json.Unmarshal([]byte(val), &final)
		if err != nil {
			logger.Error("HandleNewGetData failed1,err=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}

		resp.Result.Data.Base_data = final.Data_value

		//如果是从老的数据过来的 存入新的数据key
		if isfind {
			err = redishandler.GetRedisClient().SetString(rkey, val)
			if err != nil {
				logger.Error("HandleNewGetData err=%v", err)
			}
		}

		break
	}

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

func HandleInitIndex(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp InitIndexResp
	resp.Status = "true"

	for {

		resp.Result.Data.Env_enum = ENV_ENUM
		resp.Result.Data.Lbase64 = LBASE64
		resp.Result.Data.Res_url = RESURL
		resp.Result.Data.Version_config = VERSION_CONFIG

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleQueryInviteWork(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp InviteWorkResp
	resp.Status = "true"
	var rdata InviteWorkReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleQueryInviteWork json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			//resp.Message = "json unmarshal failed"
			break
		}

		dalist, offlist, _ := GetdagongList(rdata.Uuid)
		if dalist == nil {
			resp.Result.Code = ERROR_OK
			break
		}

		for _, val := range *dalist {
			resp.Result.Data.Invite_data = append(resp.Result.Data.Invite_data, val)
		}

		for _, val := range offlist {
			resp.Result.Data.Offlinelist = append(resp.Result.Data.Offlinelist, val)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleEnterInvite(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp EnterInviteResp
	resp.Status = "true"
	var rdata EnterInviteReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleEnterInvite json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			//resp.Message = "json unmarshal failed"
			break
		}

		//teswt
		//rdata.Invitetype = 2
		//
		if rdata.Invitetype == 1 {
			//邀请新用户
			//首先要判断一下这个玩家是否已经被邀请过了
			rkey := redis.USER_BEINVITE_UUIDRELATION + ":" + strconv.Itoa(rdata.Inviteuuid)
			exist, err := redishandler.GetRedisClient().HExists(rkey, strconv.Itoa(rdata.Selfuuid))
			if err != nil {
				logger.Error("HandleEnterInvite redis failed=%v", err)
				resp.Result.Code = ERROR_JSONUNMASHFAILED
				//resp.Message = fmt.Sprintf("%s",err)
				break
			}

			if exist {
				logger.Error("HandleEnterInvite already invited")
				resp.Result.Code = ERROR_ALREADY_INVITED
				//resp.Message = fmt.Sprintf("%s",err)
				break
			}

			//记录被邀请关系
			redishandler.GetRedisClient().HSet(rkey, strconv.Itoa(rdata.Selfuuid), strconv.Itoa(rdata.Selfuuid))

			//记录邀请关系
			rkey = redis.USER_INVITEREWARD_FETCH_REWARD + ":" + strconv.Itoa(rdata.Inviteuuid)
			redishandler.GetRedisClient().HSet(rkey, strconv.Itoa(rdata.Selfuuid), "0")
		} else {
			//邀请打工
			//invitelist,err := GetdagongList(rdata.Inviteuuid)
			invitelist, reallist, err := GetRealDagonglist(rdata.Inviteuuid)
			if err != nil {
				/*logger.Error("HandleEnterInvite GetdagongList failed")
				resp.Result.Code = ERROR_SRVDB_FAILED
				//resp.Message = fmt.Sprintf("%s",err)
				break*/
			}

			if reallist != nil {
				if len(*reallist) > 2 {
					logger.Error("HandleEnterInvite dagong num is full")
					resp.Result.Code = ERROR_DAGONG_FULL
					//resp.Message = "dagong full"
					break
				}

				//需要判断是否已经处于打工中
				if reallist.IsInWork(rdata.Selfuuid) {
					logger.Error("HandleEnterInvite IsInWork")
					resp.Result.Code = ERROR_DAGONG_FULL
					//resp.Message = "ERROR_ALREADY_INWORK"
					break
				}

				if invitelist != nil {
					err = AddDagongList(rdata.Selfuuid, rdata.Inviteuuid, *invitelist)
				} else {
					//此时列表为空 新建一个
					var newlist WorkList
					err = AddDagongList(rdata.Selfuuid, rdata.Inviteuuid, newlist)
				}

			} else {
				//此时列表为空 新建一个
				if invitelist != nil {
					err = AddDagongList(rdata.Selfuuid, rdata.Inviteuuid, *invitelist)
				} else {
					//此时列表为空 新建一个
					var newlist WorkList
					err = AddDagongList(rdata.Selfuuid, rdata.Inviteuuid, newlist)
				}
			}

			if err != nil {
				logger.Error("HandleEnterInvite ERROR_SRVDB_FAILED")
				resp.Result.Code = ERROR_SRVDB_FAILED
				//resp.Message = fmt.Sprintf("%s",err)
				break
			}
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleFetchInviteReward(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp FetchInviteResp
	resp.Status = "true"
	var rdata FetchInviteReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleFetchInviteReward json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			//resp.Message = "json unmarshal failed"
			break
		}

		rkey := redis.USER_INVITEREWARD_FETCH_REWARD + ":" + strconv.Itoa(rdata.Selfuuid)
		fetch, err := redishandler.GetRedisClient().HGet(rkey, strconv.Itoa(rdata.Fuuid))
		if err != nil {
			logger.Error("HandleFetchInviteReward redis failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			//resp.Message = fmt.Sprintf("%s",err)
			break
		}

		if fetch == "1" {
			logger.Error("HandleFetchInviteReward alreadyfetched failed=%v", err)
			resp.Result.Code = ERROR_INVITEREAWARD_FETCHED
			//resp.Message = "already fetched"
			break
		}

		//将领取记录记录
		redishandler.GetRedisClient().HSet(rkey, strconv.Itoa(rdata.Fuuid), "1")

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleRegeister(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp RegeisteraResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata RegeisterReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleRegeister json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		//todo 判断密码强度？

		//判断账号是否重复有
		exist, err := redishandler.GetRedisClient().HExists(redis.USER_ACCOUNT_PASSWORD_KEY, rdata.Account)
		if err != nil {
			logger.Error("HandleRegeister redis failed failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}

		if exist {
			logger.Error("HandleRegeister accountexist failed=%v", err)
			resp.Result.Code = ERROR_REGEISTACCOUNTEXIST
			break
		}

		err = SaveAccount(rdata.Account, rdata.Password)
		if err != nil {
			logger.Error("HandleRegeister redis failed failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}

		//需要初始化数据
		InitAccountLogin(rdata.Account)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleAccounLogin(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp AccounLoginResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata AccounLoginReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleAccounLogin json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		err := CheckAccout(rdata.Account, rdata.Password)

		if err != nil {
			logger.Error("HandleRegeister pwssword failed failed=%v", err)
			resp.Result.Code = ERROR_ACCOUNTPWDWRONG
			break
		}

		//查询数据
		token := GetAccountToken(rdata.Account)

		uuid, err := GetTouristUid(token)
		if err != nil || uuid == 0 {
			logger.Error("HandleAccounLogin getuuid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		basic, err := GetUserBasic(uuid)
		if err != nil {
			logger.Error("HandleAccounLogin getbasic failed=%v", err)
			resp.Result.Code = ERROR_GETUSERBASICFAILED
			break
		}
		resp.Result.Data.Dasedata = *basic

		ext, err := GetUserExt(uuid)
		if err != nil {
			logger.Error("HandleAccounLogin getext failed=%v", err)
			resp.Result.Code = ERROR_GETUSEREXTFAILED
			break
		}
		TransmitUserData(ext, &resp.Result.Data.Extdata)

		//需要处理登录数据
		HandleLoginTime(ext)

		m_userInfo.Set(uint32(ext.Userid), ext)
		SaveUserExt(ext)

		resp.Result.Code = ERROR_OK
		break
	}

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

//处理微信登录
func HandleWechatlogin(w http.ResponseWriter, data string) {

	SetHeader(w)
	var resp UserLoginResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata WechatLoginReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleWechatlogin json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		pc := NewWXUserDataCrypt(WETCHATAPPID, WETCHATSERCRT)
		userInfo, err := pc.Decrypt(rdata.Encrypted_data, rdata.Iv)
		if err != nil {
			logger.Error("HandleWechatlogin wechatloginfailed failed=%v", err)
			resp.Result.Code = ERROR_WECHATLOGINFAILED
			break
		}
		logger.Info("HandleWechatlogin userInfo=%v", userInfo)

		uuid, _ := GetTouristUid(userInfo.OpenID)
		if uuid == 0 {
			//新的账号 需要初始化保存
			InitWeChatUser(&rdata, &resp, userInfo)
		} else {
			//读取数据
			basic, err := GetUserBasic(uuid)
			if err != nil {
				logger.Error("HandleWechatlogin getbasic failed=%v", err)
				resp.Result.Code = ERROR_GETUSERBASICFAILED
				break
			}
			resp.Result.Data.Dasedata = *basic

			ext, err := GetUserExt(uuid)
			if err != nil {
				logger.Error("HandleWechatlogin getext failed=%v", err)
				resp.Result.Code = ERROR_GETUSEREXTFAILED
				break
			}
			TransmitUserData(ext, &resp.Result.Data.Extdata)
			//resp.Result.Data.Extdata = *ext

			//需要处理登录数据
			HandleLoginTime(ext)

			m_userInfo.Set(uint32(ext.Userid), ext)
			SaveUserExt(ext)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

//处理游客登录
func HandleTouristLogin(w http.ResponseWriter, req *UserLoginReq, resp *UserLoginResp) {

	logger.Info("HandleTouristLogin req=%v,resp=%v", req, resp)
	for {
		//首先判断是否存在这个游客账号
		uuid, err := GetTouristUid(req.Token)
		if err != nil {
			//新账号 初始化
			InitTourist(req, resp)
		} else {
			//读取数据
			basic, err := GetUserBasic(uuid)
			if err != nil {
				logger.Error("HandleTouristLogin getbasic failed=%v", err)
				resp.Result.Code = ERROR_GETUSERBASICFAILED
				break
			}
			resp.Result.Data.Dasedata = *basic

			ext, err := GetUserExt(uuid)
			if err != nil {
				logger.Error("HandleTouristLogin getext failed=%v", err)
				resp.Result.Code = ERROR_GETUSEREXTFAILED
				break
			}
			//resp.Result.Data.Extdata = *ext
			TransmitUserData(ext, &resp.Result.Data.Extdata)

			m_userInfo.Set(uint32(ext.Userid), ext)
			SaveUserExt(ext)
		}

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

func HandleUserLogin(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp UserLoginResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata UserLoginReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleUserLogin json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		HandleTouristLogin(w, &rdata, &resp)

	}

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

func HandleSaveUserData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SaveUserDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata SaveUserDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleSaveUserData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleSaveUserData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		vv := m_userInfo.Get(uint32(uuid))
		if vv == nil {
			logger.Error("HandleSaveUserData  failed=%v", err)
			resp.Result.Code = ERROR_GETUSERMAPBYUIDFAILED
			break
		}

		uinfo := vv.(*UserData)
		uinfo.Coin = rdata.Coin
		uinfo.Loevexp = rdata.Loveexp
		uinfo.Hot = rdata.Hot
		uinfo.Bean = rdata.Bean
		uinfo.Shopnum = rdata.Shopnum
		SaveUserExt(uinfo)

		basic, err := GetUserBasic(uuid)
		if err != nil {
			logger.Error("HandleTouristLogin getbasic failed=%v", err)
			resp.Result.Code = ERROR_GETUSERBASICFAILED
			break
		}
		resp.Result.Data.Dasedata = *basic

		ext, err := GetUserExt(uuid)
		if err != nil {
			logger.Error("HandleTouristLogin getext failed=%v", err)
			resp.Result.Code = ERROR_GETUSEREXTFAILED
			break
		}
		//resp.Result.Data.Extdata = *ext
		TransmitUserData(ext, &resp.Result.Data.Extdata)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandlesaveData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SaveDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata SaveDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlesaveData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandlesaveData GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		err = SaveUserBaseData(uuid, rdata.Value)

		if err != nil {
			logger.Error("HandlesaveData save failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandlegetData(w http.ResponseWriter, data string) {
	/*SetHeader(w)
	var resp GetDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandlegetData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid,err := GetTouristUid(rdata.Token)
		if err != nil || uuid==0{
			logger.Error("HandlegetData GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}


		ubase,err := GetUserBaseData(uuid)

		if err != nil {
			logger.Error("HandlegetData get failed=%v", err)
			resp.Result.Code = ERROR_SRVDB_FAILED
			break
		}

		resp.Result.Data.Base_data = ubase
		resp.Result.Code = ERROR_OK
		break
	}

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

func GetAccessToken() string {
	//首先从缓存取kwiffwiffiaowosfwkfko
	exist, err := redishandler.GetRedisClient().Exists(redis.MSG_CKECK_ACCESSTOKEN)
	if err != nil {
		logger.Error("GetAccessToken err=%v", err)
		return ""
	}

	if exist {
		key, err := redishandler.GetRedisClient().GetString(redis.MSG_CKECK_ACCESSTOKEN)
		if err != nil {
			logger.Error("GetAccessToken err=%v", err)
			return ""
		}

		return key
	}

	//去微信获取
	url := URL_WEIXINGETACCESS_TOKEN + "?grant_type=client_credential&" + "appid=wx572a2a5ec4538f33&" + "secret=b31e2e7406af88fe7395cd178bdb64fc"
	res, err := http.Get(url)
	if err != nil {
		logger.Error("GetAccessToken http failed err=%v", err)
		return ""
	}

	result, _ := ioutil.ReadAll(res.Body)
	defer res.Body.Close()

	var msgresp GetAccessTokenResp
	_ = json.Unmarshal(result, &msgresp)

	//存入缓存
	expiretime, _ := strconv.Atoi(msgresp.Expires_in)
	redishandler.GetRedisClient().SetExString(redis.MSG_CKECK_ACCESSTOKEN, msgresp.Access_token, expiretime-60)

	return msgresp.Access_token
}

func HandleTextCheck(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp TextCheckResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata TextCheckReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleTextCheck json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleTextCheck GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//首先获取
		msgtoken := GetAccessToken()
		msgurl := URL_WEIXINMSG_CHECK + "?access_token=" + msgtoken
		var check MsgCheckDesc
		check.Content = rdata.Text
		bys, err := json.Marshal(&check)
		if err != nil {
			logger.Error("HandleTextCheck json failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		body := bytes.NewBuffer(bys)
		res, err := http.Post(msgurl, "application/json;charset=utf-8", body)
		if err != nil {
			logger.Error(" HandleTextCheck ERROR_HTTPPOSTFAILED err=%v", err)
			resp.Result.Code = ERROR_HTTPPOSTFAILED
			return
		}

		result, _ := ioutil.ReadAll(res.Body)
		defer res.Body.Close()

		var msgresp MsgCheckResp
		_ = json.Unmarshal(result, &msgresp)

		//code, _ := strconv.Atoi(msgresp.Errcode)
		resp.Result.Code = msgresp.Errcode
		resp.Result.Data = msgresp.Errmsg

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleCreateTeam(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp CreateTeamResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata CreateTeamReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleCreateTeam json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleCreateTeam GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//首先判断一下当前队伍名称是否已经存在
		isexist := GetUserTeamNameIsExist(rdata.Name)
		if isexist {
			logger.Error("HandleCreateTeam name mulit failed=%v", err)
			resp.Result.Code = ERROR_TEAM_ALREADYEXIST
			break
		}

		/*//判断店铺数量
		vv := m_userInfo.Get(uint32(uuid))
		if vv == nil {
			logger.Error("HandleCreateTeam  failed=%v", err)
			resp.Result.Code = ERROR_GETUSERMAPBYUIDFAILED
			break
		}

		uinfo := vv.(*UserData)
		if uinfo.Shopnum < rdata.Limit {
			logger.Error("HandleCreateTeam  failed=%v", err)
			resp.Result.Code = ERROR_CREATE_SHOPNOTENOUGH
			break
		}*/

		//初始化队伍数据
		var bteaminfo TeamInfo
		bteaminfo.MemInfo.MemList = append(bteaminfo.MemInfo.MemList, uuid)
		var teaminfo CreateTeamInfo
		teaminfo.Name = rdata.Name
		teaminfo.Status = 0
		teaminfo.Id = GetNewTeamId()
		teaminfo.Assets = 0
		teaminfo.Captain_id = uuid
		teaminfo.Creator_id = uuid
		teaminfo.Create_time = int(time.Now().Unix())
		teaminfo.Is_open = rdata.Is_open
		teaminfo.Least = rdata.Limit
		teaminfo.Num = 1
		teaminfo.Update_time = int(time.Now().Unix())
		resp.Result.Data.Team_data = teaminfo
		bteaminfo.BaseInfo = teaminfo
		//保存队伍数据
		SaveTeamInfo(teaminfo.Id, &bteaminfo)

		//保存队伍id
		SaveTeamToUuid(teaminfo.Id, uuid)

		//保存队伍名称
		SetUserTeamName(rdata.Name, teaminfo.Id)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleUpdateTeamData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SaveDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata CreateTeamReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleUpdateTeamData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleUpdateTeamData GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//首先判断一下当前队伍名称是否已经存在
		isexist := GetUserTeamNameIsExist(rdata.Name)
		if isexist {
			logger.Error("HandleUpdateTeamData name mulit failed=%v", err)
			resp.Result.Code = ERROR_TEAM_ALREADYEXIST
			break
		}

		//首先查询teamid
		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleUpdateTeamData getteamid failed=%v", err)
			resp.Result.Code = ERROR_QUERYTEAMID_FAILED
			break
		}
		//查询队伍数据
		teaminfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleUpdateTeamData getteaminfo failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}

		if teaminfo.BaseInfo.Creator_id != uuid {
			logger.Error("HandleUpdateTeamData notcaption failed=%v", err)
			resp.Result.Code = ERROR_NOTCAPTION
			break
		}
		if teaminfo.BaseInfo.Name == rdata.Name {
			logger.Error("HandleUpdateTeamData namesame failed=%v", err)
			resp.Result.Code = ERROR_TEAMNAMETHSDAME
			break
		}

		orinname := teaminfo.BaseInfo.Name
		teaminfo.BaseInfo.Name = rdata.Name
		teaminfo.BaseInfo.Is_open = rdata.Is_open
		teaminfo.BaseInfo.Least = rdata.Limit
		teaminfo.BaseInfo.Update_time = int(time.Now().Unix())

		//保存队伍数据
		SaveTeamInfo(teaminfo.BaseInfo.Id, teaminfo)

		DelUserTeamName(orinname)
		//保存队伍名称
		SetUserTeamName(rdata.Name, teaminfo.BaseInfo.Id)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleJoinTeam(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp JoinTeamResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata JoinTeamReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleJoinTeam json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleJoinTeam GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//获取店铺数据
		tinfo, err := GetTeamInfo(rdata.Team_id)
		if err != nil {
			logger.Error("HandleJoinTeam GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}

		//判断店铺数量
		vv := m_userInfo.Get(uint32(uuid))
		if vv == nil {
			logger.Error("HandleJoinTeam  failed=%v", err)
			resp.Result.Code = ERROR_GETUSERMAPBYUIDFAILED
			break
		}

		//需要判断队伍人数是否已满
		if len(tinfo.MemInfo.MemList) > TEAM_MAXNUM {
			logger.Error("HandleJoinTeam  failed=%v", err)
			resp.Result.Code = ERROR_TEAMISMAX
			break
		}

		uinfo := vv.(*UserData)
		if uinfo.Shopnum < tinfo.BaseInfo.Least {
			logger.Error("HandleJoinTeam  failed=%v", err)
			resp.Result.Code = ERROR_CREATE_SHOPNOTENOUGH
			break
		}

		//判断一下是否已经在队伍中
		inteam := tinfo.IsInTeam(uuid)

		if inteam {
			logger.Error("HandleJoinTeam  already inteam failed=%v", err)
			resp.Result.Code = ERROR_TEAMALREADYINTEAM
			break
		}

		tinfo.MemInfo.MemList = append(tinfo.MemInfo.MemList, uuid)

		//保存队伍与uuid
		SaveTeamToUuid(tinfo.BaseInfo.Id, uuid)
		//保存队伍数据
		SaveTeamInfo(tinfo.BaseInfo.Id, tinfo)

		resp.Result.Code = ERROR_OK
		resp.Result.Data = ""
		break
	}

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

func HandleJoinTeamByInvite(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp JoinTeamByInviteResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata JoinTeamByInviteReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleJoinTeamByInvite json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleJoinTeamByInvite GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//获取店铺数据
		teamid, err := GetTeamByUuid(rdata.Inviter_id)
		if err != nil {
			logger.Error("HandleJoinTeamByInvite GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleJoinTeamByInvite GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}

		//判断一下是否已经在队伍中
		inteam := tinfo.IsInTeam(uuid)

		if inteam {
			logger.Error("HandleJoinTeamByInvite  already inteam failed=%v", err)
			resp.Result.Code = ERROR_TEAMALREADYINTEAM
			break
		}

		tinfo.MemInfo.MemList = append(tinfo.MemInfo.MemList, uuid)

		//保存队伍与uuid
		SaveTeamToUuid(tinfo.BaseInfo.Id, uuid)
		//保存队伍数据
		SaveTeamInfo(tinfo.BaseInfo.Id, tinfo)

		resp.Result.Code = ERROR_OK
		resp.Result.Data = ""
		break
	}

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

func HandleQuitTeam(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp QuitTeamResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata QuitTeamReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleQuitTeam json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleQuitTeam GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleQuitTeam GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleQuitTeam GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		//判断一下是否已经在队伍中
		inteam := tinfo.IsInTeam(uuid)

		if !inteam {
			logger.Error("HandleQuitTeam  not inteam failed=%v", err)
			resp.Result.Code = ERROR_TEAMNOTINTEAM
			break
		}

		if rdata.Type == 0 {
			//踢人 需要判断是否是队长
			if uuid != tinfo.BaseInfo.Captain_id {
				logger.Error("HandleQuitTeam  not caption failed=%v", err)
				resp.Result.Code = ERROR_NOTCAPTION
				break
			}
		} else {
			//主动离开 需要扣除投资额
			//todo 扣除投资额
		}

		//删除成员信息
		//tinfo.MemInfo.MemList = append(tinfo.MemInfo.MemList,uuid)
		tinfo.DelTeamMember(rdata.User_id)

		//保存队伍数据
		SaveTeamInfo(tinfo.BaseInfo.Id, tinfo)

		resp.Result.Code = ERROR_OK
		resp.Result.Data = ""
		break
	}

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

func HandleUpdateTeamBuild(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp UpdateTeamBuildResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata UpdateTeamBuildReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleUpdateTeamBuild json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleUpdateTeamBuild GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleUpdateTeamBuild GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleUpdateTeamBuild GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		//判断一下是否已经在队伍中
		inteam := tinfo.IsInTeam(uuid)

		if !inteam {
			logger.Error("HandleQuitTeam  not inteam failed=%v", err)
			resp.Result.Code = ERROR_TEAMNOTINTEAM
			break
		}

		//处理投资
		tinfo.DoDevote(rdata.Build_type, rdata.Assets, uuid, rdata.Muti)

		//保存队伍数据
		SaveTeamInfo(tinfo.BaseInfo.Id, tinfo)

		for _, val := range tinfo.BInfo.Devote {
			resp.Result.Data.Build_list = append(resp.Result.Data.Build_list, val)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleAddTeamBuff(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp AddTeamBuffResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata AddTeamBuffReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleAddTeamBuff json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleAddTeamBuff GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleAddTeamBuff GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleAddTeamBuff GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		//判断一下是否已经在队伍中
		inteam := tinfo.IsInTeam(uuid)

		if !inteam {
			logger.Error("HandleAddTeamBuff  not inteam failed=%v", err)
			resp.Result.Code = ERROR_TEAMNOTINTEAM
			break
		}

		//处理buff
		tinfo.DoAddBuffTimee(rdata.Build_type, rdata.Muti, &resp)

		//保存队伍数据
		SaveTeamInfo(tinfo.BaseInfo.Id, tinfo)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetTeamBuff(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetTeamBuffResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetTeamBuffReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetTeamBuff json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetTeamBuff GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleGetTeamBuff GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleGetTeamBuff GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}

		//处理buff
		for _, vak := range tinfo.BInfo.Buff {
			var tmp AddTeamBuffSpec
			tmp.Build_type = vak.Type
			for _, val1 := range vak.BuffInfo {
				var tmp1 BuffTimeInfo
				tmp1.Buff_begin_time = val1.BeginTime
				tmp1.Buff_end_time = val1.EndTime
				tmp.Buff_time = append(tmp.Buff_time, tmp1)
			}
			resp.Result.Data.Build_list = append(resp.Result.Data.Build_list, tmp)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetTeamData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetTeamDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetTeamDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetTeamData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetTeamData GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teamid, err := GetTeamByUuid(uuid)
		if err != nil {
			logger.Error("HandleGetTeamData GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}
		tinfo, err := GetTeamInfo(teamid)
		if err != nil {
			logger.Error("HandleGetTeamData GetTeamInfoFailed failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMINFO_FAILED
			break
		}

		resp.Result.Data.Team_data = tinfo.BaseInfo
		for _, val := range tinfo.MemInfo.MemList {
			var tmp GetTeamDataTeamUserList
			tmp.Uuid = val
			resp.Result.Data.Team_user_list = append(resp.Result.Data.Team_user_list, tmp)
		}
		for _, val := range tinfo.BInfo.Devote {
			var tmp TeamDevoteInfo
			tmp = val
			resp.Result.Data.Build_list.Build_list = append(resp.Result.Data.Build_list.Build_list, tmp)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetDataByUserId(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetDataByUserIdResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetDataByUserIdReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetDataByUserId json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetDataByUserId GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		basic, err := GetUserBasic(rdata.User_id)
		if err != nil {
			logger.Error("HandleGetDataByUserId GetUserBasic failed=%v", err)
			resp.Result.Code = ERROR_GETUSERINFOBYIDFAILED
			break
		}
		base, err := GetUserBaseData(rdata.User_id)
		if err != nil {
			logger.Error("HandleGetDataByUserId GetUserBase failed=%v", err)
			resp.Result.Code = ERROR_GETUSERINFOBYIDFAILED
			break
		}
		ext, err := GetUserExt(rdata.User_id)
		if err != nil {
			logger.Error("HandleGetDataByUserId GetUserExt failed=%v", err)
			resp.Result.Code = ERROR_GETUSERINFOBYIDFAILED
			break
		}

		resp.Result.Data.Base_data = base
		resp.Result.Data.User_base_data = *basic
		//resp.Result.Data.Extdata = *ext
		TransmitUserData(ext, &resp.Result.Data.Extdata)
		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetTeamList(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetTeamListResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetTeamListReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetTeamList json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetTeamList GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teams, err, sum := GetTeamListByCond(rdata.Store_num, rdata.Page)
		if err != nil {
			logger.Error("HandleGetTeamList GetTeamListByCond failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMLISTFAILED
			break
		}

		resp.Result.Data.Count = sum
		for _, val := range teams {
			resp.Result.Data.Items = append(resp.Result.Data.Items, val.BaseInfo.Id)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleSearchTeam(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SearchTeamResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata SearchTeamReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleSearchTeam json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleSearchTeam GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		teams, err, sum := GetTeamListByNameCond(rdata.Store_num, rdata.Page, rdata.Name)
		if err != nil {
			logger.Error("HandleSearchTeam GetTeamListByCond failed=%v", err)
			resp.Result.Code = ERROR_GETTEAMLISTFAILED
			break
		}

		resp.Result.Data.Count = sum
		for _, val := range teams {
			resp.Result.Data.Items = append(resp.Result.Data.Items, val.BaseInfo.Id)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleSetFriendRequest(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp SetFriendResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata SetFriendReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleSetFriendRequest json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleSetFriendRequest GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//先判断是否是好友关系
		list, err := GetUserFriendList(rdata.User_id)
		if err != nil {
			logger.Error("HandleSetFriendRequest GetFriendList failed=%v", err)
			resp.Result.Code = ERROR_GETFRIENDLISTAILED
			break
		}
		inlist := list.IsInFreiendList(uuid)
		if inlist {
			logger.Error("HandleSetFriendRequest InFriendList failed=%v", err)
			resp.Result.Code = ERROR_INLISTAILED
			break
		}

		//判断自己的好友人数是否已经达到上限
		ownlist, err := GetUserFriendList(uuid)
		if err != nil {
			logger.Error("HandleSetFriendRequest GetFriendList failed=%v", err)
			resp.Result.Code = ERROR_GETFRIENDLISTAILED
			break
		}
		//判断好友人数上限
		if len(list.Friends) >= FRIEND_MAX_NUM || len(ownlist.Friends) >= FRIEND_MAX_NUM {
			logger.Error("HandleSetFriendRequest FRIENDMAX failed=%v", err)
			resp.Result.Code = ERROR_FRIENDISMAX
			break
		}

		//判断申请列表是否已经有对该玩家的申请 24小时，此处需要判断24小时内的申请次数上限，需要先提出超过24小时的申请
		applylist, err := GetUserApplyList(uuid)
		if err != nil {
			logger.Error("HandleSetFriendRequest GetApplyListFailed failed=%v", err)
			resp.Result.Code = ERROR_FRIENDGETAPPLISTFAILED
			break
		}

		if applylist.InApplyList(rdata.User_id) {
			logger.Error("HandleSetFriendRequest ALREDAYINAPPLYLIST failed=%v", err)
			resp.Result.Code = ERROR_FRIENDALREDAYINAPPLYLIST
			break
		}

		if len(applylist.Apply_info) >= FRIEND_APPLY_LIMIT {
			logger.Error("HandleSetFriendRequest Apply limit failed=%v", err)
			resp.Result.Code = ERROR_FRIENDAPPLYLIMIT
			break
		}

		//加入对方列表，如果已经在对方待批准列表则返回错误
		approvelist, err := GetUserApproveList(rdata.User_id)
		if err != nil {
			logger.Error("HandleSetFriendRequest GetApproveListFailed failed=%v", err)
			resp.Result.Code = RROR_FRIENDGETAPPROVELISTFAILED
			break
		}

		if approvelist.InApproveList(uuid) {
			logger.Error("HandleSetFriendRequest inApprovelist  failed=%v", err)
			resp.Result.Code = RROR_FRIENDINAPPROVELISTFAILED
			break
		}

		if len(approvelist.Approve_info) >= FRIEND_APPROVE_LIMIT {
			logger.Error("HandleSetFriendRequest Apply limit failed=%v", err)
			resp.Result.Code = ERROR_FRIENDAPPROVELIMIT
			break
		}

		//添加到对方的待批准记录
		SaveUserApplyList(uuid, rdata.User_id)

		//添加到自己的申请记录
		SaveUserApproveList(rdata.User_id, uuid)

		//清空好友推荐缓存
		DelCacheRecommandFriendList(uuid)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetFriendList(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetFriendListResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetFriendListReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetFriendList json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetFriendList GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		friendlist, err := GetUserFriendList(uuid)
		if err != nil {
			logger.Error("HandleSetFriendRequest GetFriendList failed=%v", err)
			resp.Result.Code = ERROR_GETFRIENDLISTAILED
			break
		}
		resp.Result.Data.Friend_list = append(resp.Result.Data.Friend_list, friendlist.Friends...)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetAuditList(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetAuditListResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetAuditListReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetAuditList json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetAuditList GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		approvelist, err := GetUserApproveList(uuid)
		if err != nil {
			logger.Error("HandleGetAuditList Getapprovelistfailedt failed=%v", err)
			resp.Result.Code = RROR_FRIENDGETAPPROVELISTFAILED
			break
		}
		resp.Result.Data.Approve_list = append(resp.Result.Data.Approve_list, approvelist.Approve_info...)

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleGetRecommendList(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp GetRecommendListResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata GetRecommendListReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleGetRecommendList json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleGetRecommendList GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		//需要判断自己的好友位置是否已满
		friendlist, err := GetUserFriendList(uuid)
		if err != nil {
			logger.Error("HandleGetRecommendList GetFriendList failed=%v", err)
			resp.Result.Code = ERROR_GETFRIENDLISTAILED
			break
		}
		if len(friendlist.Friends) >= FRIEND_MAX_NUM {
			//好友位已经满了不再做推荐
			resp.Result.Code = ERROR_OK
			break
		}

		rlist, err := friendlist.GetRecommandFriendList(uuid, FRIEND_RECOMMAND_NUM)
		if err != nil {
			logger.Error("HandleGetRecommendList GetRecommandFriendList failed=%v", err)
			resp.Result.Code = ERROR_FRIENDGETRECOMMADNFAILED
			break
		}

		for _, val := range rlist.Recommend_list {
			resp.Result.Data.Recommend_list = append(resp.Result.Data.Recommend_list, val)
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleHandleFriendRequest(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp HandleFriendRequestResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata HandleFriendRequestReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleHandleFriendRequest json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleHandleFriendRequest GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		approvelist, err := GetUserApproveList(uuid)
		if !approvelist.InApproveList(rdata.User_id) {
			logger.Error("HandleHandleFriendRequest NOTINAPPROVELIST failed=%v", err)
			resp.Result.Code = ERROR_NOTINAPPROVELIST
			break
		}

		//从待批准列表删除
		err = DelFromApproveList(uuid, rdata.User_id)
		if err != nil {
			logger.Error("HandleHandleFriendRequest ERROR_FRIENDAPPROVEFAILED failed=%v", err)
			resp.Result.Code = ERROR_FRIENDAPPROVEFAILED
			break
		}

		if rdata.Type == 0 {
			//如果同意将其加入好友列表 status 1表示删除 0表示未删除
			err = SaveUserFriendList(uuid, rdata.User_id, 0)
			if err != nil {
				logger.Error("HandleHandleFriendRequest ERROR_FRIENDAPPROVEFAILED failed=%v", err)
				resp.Result.Code = ERROR_FRIENDAPPROVEFAILED
				break
			}
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleDelFriend(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp DelFriendResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata DelFriendReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleDelFriend json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleDelFriend GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		friendlist, err := GetUserFriendList(uuid)
		if err != nil {
			logger.Error("HandleDelFriend GetFriendList failed=%v", err)
			resp.Result.Code = ERROR_GETFRIENDLISTAILED
			break
		}
		if !friendlist.IsInFreiendList(rdata.User_id) {
			logger.Error("HandleSetFriendRequest ERROR_FRIENDNOTFRIEND failed=%v", err)
			resp.Result.Code = ERROR_FRIENDNOTFRIEND
			break
		}

		err = SaveUserFriendList(uuid, rdata.User_id, 1)
		if err != nil {
			logger.Error("HandleSetFriendRequest ERROR_FRIENDAPPROVEFAILED failed=%v", err)
			resp.Result.Code = ERROR_FRIENDDELFRIENDFAILED
			break
		}

		resp.Result.Code = ERROR_OK
		break
	}

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

func HandleQueryPlayerData(w http.ResponseWriter, data string) {
	SetHeader(w)
	var resp QueryPlayerDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata QueryPlayerDataReq
	err := json.Unmarshal([]byte(data), &rdata)
	for {
		if err != nil {
			logger.Error("HandleQueryPlayerData json unmarshal failed=%v", err)
			resp.Result.Code = ERROR_JSONUNMASHFAILED
			break
		}

		uuid, err := GetTouristUid(rdata.Token)
		if err != nil || uuid == 0 {
			logger.Error("HandleQueryPlayerData GetTouristUid failed=%v", err)
			resp.Result.Code = ERROR_GETUSERIDFAILED
			break
		}

		finfo := GetFfiendData(rdata.User_id)
		if finfo == nil {
			logger.Error("HandleQueryPlayerData ERROR_FRIENDGETFRIENDINFOFAILED failed=%v", err)
			resp.Result.Code = ERROR_FRIENDGETFRIENDINFOFAILED
			break
		}

		resp.Result.Data.Player_data = *finfo

		resp.Result.Code = ERROR_OK
		break
	}

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