package logic

import (
	"HttpServer/redishandler"
	"bytes"
	"common/beegomap"
	"common/logger"
	"common/redis"
	"io/ioutil"
	"strconv"

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

	"time"
)

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

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



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

	SaveUserExt(udata)

}

//处理游客登录
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

			m_userInfo.Set(uint32(ext.User_id),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
		}

		if rdata.Logintype ==LOGIN_TYPE_TOURIST {
			//游客登录
			HandleTouristLogin(w,&rdata,&resp)
			break
		}

		if rdata.Logintype == LOGIN_TYPE_ACCOUNT {
			//账号密码登录

			break
		}

		if rdata.Logintype == LOGIN_TYPE_WECHAT {
			//微信登录

			break
		}


	}

	//回包
	//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

		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{
	//首先从缓存取
	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
		}

		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

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