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 SaveDataResp
	resp.Status = "true"
	resp.Result.Code = ERROR_OK
	var rdata SaveDataReq
	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 = 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)

		//保存队伍数据
		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)

		//保存队伍数据
		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))
}