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 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 := "cat:cafe:data:where:data_uid:" + strconv.Itoa(rdata.Uuid)
		val,err := redishandler.GetRedisClient().GetString(rkey)
		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
		}

		//解析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"].(int) < c1["level"].(int) {
						logger.Error("HandleNewSaveData failed2,err=%v", err)
						resp.Result.Code = ERROR_SRVDB_FAILED
						resp.Result.Data = "ERROR_SRVDB_FAILED"
						break
					}
				}
			}
		}

		//比较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
				}
			}
		}

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

		//全部校验过后
		err = redishandler.GetRedisClient().SetString(rkey,rdata.Value)
		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
		}

		rkey := "cat:cafe:data:where:data_uid:" + strconv.Itoa(rdata.Uuid)

		 val,err := redishandler.GetRedisClient().GetString(rkey)
		 if err != nil {
		 	logger.Error("HandleNewGetData err=%v",err)
			 resp.Result.Code = ERROR_JSONUNMASHFAILED
			 break
		 }
		resp.Result.Data.Base_data = val
		logger.Info("HandleNewGetData new is=%v",val)

		break
	}

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