package logic

import (
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"math/rand"
	"mysql"
	"net/http"
	"sort"
	"strconv"
	"strings"
	"time"
)

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

func (tinfo *TeamInfo) DoAddBuffTimee(btype int, muti int, resp *AddTeamBuffResp) {
	addtime := 1800 * muti
	index := 0
	for k, val := range tinfo.BInfo.Buff {
		if val.Type == btype {
			index = k
		}
	}

	for i := 0; i < len(tinfo.BInfo.Buff[index].BuffInfo); i++ {
		tinfo.BInfo.Buff[index].BuffInfo[i].EndTime += addtime
	}

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

func (tinfo *TeamInfo) DoDevote(btype int, assets int, uuid int, muti int) {
	bfind := false
	for k, val := range tinfo.BInfo.Devote {
		if val.Type == btype {
			tinfo.BInfo.Devote[k].Assets += assets
			bfind = true
			break
		}
	}
	if !bfind {
		var tmp TeamDevoteInfo
		tmp.UserId = uuid
		tmp.Assets = assets
		tmp.Type = btype
		tinfo.BInfo.Devote = append(tinfo.BInfo.Devote, tmp)
	}

	//需要处理一下buff
	nowtime := int(time.Now().Unix())
	addTime := 1800 * muti
	var index = 0
	for k, val := range tinfo.BInfo.Buff {
		if val.Type == btype {
			index = k
		}
	}
	if tinfo.BInfo.Buff[index].BuffInfo[len(tinfo.BInfo.Buff[index].BuffInfo)-1].EndTime < nowtime+86399 {
		if tinfo.BInfo.Buff[index].BuffInfo[len(tinfo.BInfo.Buff[index].BuffInfo)-1].EndTime >= nowtime {
			tinfo.BInfo.Buff[index].BuffInfo[len(tinfo.BInfo.Buff[index].BuffInfo)-1].EndTime += addTime
		} else {
			var tmp TeamBuffInfo
			tmp.BeginTime = nowtime
			tmp.EndTime = nowtime + addTime
			tinfo.BInfo.Buff[index].BuffInfo = append(tinfo.BInfo.Buff[index].BuffInfo, tmp)
		}
	} else {
		tinfo.BInfo.Buff[index].BuffInfo[len(tinfo.BInfo.Buff[index].BuffInfo)-1].EndTime += 86399
	}

	//删除掉无用的
	yestime := nowtime - 86400
	for i := 0; i < len(tinfo.BInfo.Buff[index].BuffInfo); i++ {
		v := tinfo.BInfo.Buff[index].BuffInfo[i]
		if v.BeginTime < yestime && v.EndTime < yestime {
			tinfo.BInfo.Buff = append(tinfo.BInfo.Buff[:i], tinfo.BInfo.Buff[i+1:]...)
			i--
		}
	}
}

func (tinfo *TeamInfo) IsInTeam(uuid int) bool {
	inteam := false
	for _, val := range tinfo.MemInfo.MemList {
		if val == uuid {
			inteam = true
			break
		}
	}
	return inteam
}

func (tinfo *TeamInfo) DelTeamMember(uuid int) {

	for k, val := range tinfo.MemInfo.MemList {
		if val == uuid {
			tinfo.MemInfo.MemList = append(tinfo.MemInfo.MemList[:k], tinfo.MemInfo.MemList[k+1:]...)
			break
		}
	}

	//删除team关系
	SaveTeamToUuid(0, uuid)

}

//设置
func SetTouristUid(utoken string, uid int) error {
	err := redishandler.GetRedisClient().HSet(redis.USER_TOURIST_UID, utoken, strconv.Itoa(uid))
	if err != nil {
		logger.Error("SetTouristUid failed,err=%v", err)
		return err
	}
	return nil
}

//获取游客的uid 返回值为uid
func GetTouristUid(utoken string) (int, error) {
	uidstr, err := redishandler.GetRedisClient().HGet(redis.USER_TOURIST_UID, utoken)
	if err != nil {
		return 0, err
	}

	uid, err := strconv.Atoi(uidstr)
	return uid, err
}

//获取玩家新的uuid
func GetNewUUid() int {
	redishandler.GetRedisClient().Incr(redis.USER_MAX_UUID)
	newuuid, err := redishandler.GetRedisClient().GetInt(redis.USER_MAX_UUID)
	if err != nil {
		logger.Error("GetNewUUid failed,err=%v", err)
		return 0
	}

	return newuuid + 100000
}

//获取新的teamid
func GetNewTeamId() int {
	redishandler.GetRedisClient().Incr(redis.TEAM_MAX_UUID)
	newuuid, err := redishandler.GetRedisClient().GetInt(redis.TEAM_MAX_UUID)
	if err != nil {
		logger.Error("GetNewUUid failed,err=%v", err)
		return 0
	}

	return newuuid + 100000
}

func SaveUserBaseData(uuid int, value string) error {
	err := redishandler.GetRedisClient().HSet(redis.USER_BASE_DATA, strconv.Itoa(uuid), value)
	return err
}

func GetUserBaseData(uuid int) (string, error) {
	strval, err := redishandler.GetRedisClient().HGet(redis.USER_BASIC_DATA, strconv.Itoa(uuid))
	if err != nil {
		logger.Error("GetUserBasic failed,err=%v", err)
		return "", err
	}

	return strval, err

}

func SaveUserBasic(uuid int, value string) error {
	err := redishandler.GetRedisClient().HSet(redis.USER_BASIC_DATA, strconv.Itoa(uuid), value)
	return err
}

func GetUserBasic(uuid int) (*UserBaseData, error) {
	strval, err := redishandler.GetRedisClient().HGet(redis.USER_BASIC_DATA, strconv.Itoa(uuid))
	if err != nil {
		logger.Error("GetUserBasic failed,err=%v", err)
		return nil, err
	}
	basic := new(UserBaseData)
	err = json.Unmarshal([]byte(strval), basic)
	return basic, err

}

func SaveUserExt(extdata *UserData) error {
	if extdata == nil {
		return nil
	}
	m_userInfo.Set(uint32(extdata.Userid), extdata)

	ext, _ := json.Marshal(&extdata)
	err := redishandler.GetRedisClient().HSet(redis.USER_EXT_DATA, strconv.Itoa(extdata.Userid), string(ext))
	return err
}

func GetUserExt(uuid int) (*UserData, error) {
	strval, err := redishandler.GetRedisClient().HGet(redis.USER_EXT_DATA, strconv.Itoa(uuid))
	if err != nil {
		logger.Error("GetUserExt failed,err=%v", err)
		return nil, err
	}
	ext := new(UserData)
	err = json.Unmarshal([]byte(strval), ext)
	return ext, err
}

//检测队伍名称是否已经存在
func GetUserTeamNameIsExist(name string) bool {
	_, err := redishandler.GetRedisClient().HGet(redis.TEAM_USERTEAM_NAME, name)
	if err != nil {
		return true
	}
	return false
}

//删除存储的队伍名称
func DelUserTeamName(name string) error {
	err := redishandler.GetRedisClient().HDel(redis.TEAM_USERTEAM_NAME, name)
	if err != nil {
		logger.Error("SetUserTeamName err=%v),err")
	}
	return err
}

//存储队伍名称
func SetUserTeamName(name string, teamid int) {
	err := redishandler.GetRedisClient().HSet(redis.TEAM_USERTEAM_NAME, name, strconv.Itoa(teamid))
	if err != nil {
		logger.Error("SetUserTeamName err=%v),err")
	}
}

//保存队伍信息
func SaveTeamInfo(teamid int, tinfo *TeamInfo) error {
	team, _ := json.Marshal(tinfo)
	err := redishandler.GetRedisClient().HSet(redis.TEAM_INFO, strconv.Itoa(teamid), string(team))
	if err != nil {
		logger.Error("SaveTeamInfo err=%v),err")
		return err
	}
	return nil
}

//获取队伍信息
func GetTeamInfo(teamid int) (*TeamInfo, error) {
	info := new(TeamInfo)
	vv, err := redishandler.GetRedisClient().HGet(redis.TEAM_INFO, strconv.Itoa(teamid))
	if err != nil {
		logger.Error("GetTeamInfo failed,err=%v", err)
		return nil, err
	}

	err = json.Unmarshal([]byte(vv), info)
	return info, err
}

//保存teamid与uuid
func SaveTeamToUuid(teamid, uuid int) error {
	err := redishandler.GetRedisClient().HSet(redis.TEAM_TEAMID_TOUUID, strconv.Itoa(uuid), strconv.Itoa(teamid))
	if err != nil {
		logger.Error("SaveTeamToUuid err=%v),err")
		return err
	}
	return nil
}

//获取teamid与uuid
func GetTeamByUuid(uuid int) (int, error) {
	vv, err := redishandler.GetRedisClient().HGet(redis.TEAM_TEAMID_TOUUID, strconv.Itoa(uuid))
	if err != nil {
		logger.Error("GetTeamByUuid failed,err=%v", err)
		return 0, err
	}

	teamid, err := strconv.Atoi(vv)
	return teamid, err
}

type TeamSlice []*TeamInfo

func (a TeamSlice) Len() int { // 重写 Len() 方法
	return len(a)
}
func (a TeamSlice) Swap(i, j int) { // 重写 Swap() 方法
	a[i], a[j] = a[j], a[i]
}
func (a TeamSlice) Less(i, j int) bool { // 重写 Less() 方法， 从大到小排序
	return a[j].BaseInfo.Assets < a[i].BaseInfo.Assets
}

//获取所有的team,分页 传入页签
func GetTeamListByCond(shopnum int, page int) (TeamSlice, error, int) {
	if page < 0 {
		logger.Error("GetTeamListByCond invalid page=%v", page)
		page = 1
	}
	var rtslice TeamSlice
	vv, err := redishandler.GetRedisClient().HGetAllValues(redis.TEAM_INFO)
	if err != nil {
		logger.Error("GetTeamListByCond err")
		return nil, err, 0
	}

	for _, val := range vv {
		one := new(TeamInfo)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err == nil {
			if one.BaseInfo.Num <= shopnum {
				rtslice = append(rtslice, one)
			}
		}
	}
	//排序
	sort.Sort(rtslice)

	begin := (page - 1) * 10
	end := begin + 9
	sumlen := len(rtslice)
	if begin > sumlen {
		begin = sumlen - 10
	}
	if end > sumlen {
		end = sumlen - 1
	}

	return rtslice[begin:end], nil, sumlen

}

func GetTeamListByNameCond(shopnum int, page int, name string) (TeamSlice, error, int) {
	if page < 0 {
		logger.Error("GetTeamListByCond invalid page=%v", page)
		page = 1
	}
	var rtslice TeamSlice
	vv, err := redishandler.GetRedisClient().HGetAllValues(redis.TEAM_INFO)
	if err != nil {
		logger.Error("GetTeamListByCond err")
		return nil, err, 0
	}

	for _, val := range vv {
		one := new(TeamInfo)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err == nil {
			if one.BaseInfo.Num <= shopnum && strings.Index(one.BaseInfo.Name, name) != -1 {
				rtslice = append(rtslice, one)
			}
		}
	}
	//排序
	sort.Sort(rtslice)

	begin := (page - 1) * 10
	end := begin + 9
	sumlen := len(rtslice)
	if begin > sumlen {
		begin = sumlen - 10
	}
	if end > sumlen {
		end = sumlen - 1
	}

	return rtslice[begin:end], nil, sumlen

}

func (alist *ApproveList) InApproveList(uuid int) bool {
	for _, val := range alist.Approve_info {
		if val.Uuid == uuid {
			return true
		}
	}
	return false
}

//
func DelFromApproveList(uuid, deluuid int) error {
	return nil
}

//待批准列表
func GetUserApproveList(uuid int) (*ApproveList, error) {
	rt := new(ApproveList)
	//存储为hset key为 固定key+uuid ,field为被添加者的uuid,fieldW为FriendInfo
	userkey := redis.FRIEND_APPROVELIST_KEY + ":" + strconv.Itoa(uuid)
	vv, err := redishandler.GetRedisClient().HGetAllValues(userkey)
	if err != nil {
		logger.Error("GetUserApproveList err")
		return nil, err
	}

	nowtime := int(time.Now().Unix())
	for _, val := range vv {
		one := new(ApplyInfo)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err != nil {
			//需要剔除超过时间的
			if nowtime <= one.Apply_time+3*86400 {
				rt.Approve_info = append(rt.Approve_info, *one)
			} else {
				//已经超时，需要删除
				redishandler.GetRedisClient().HDel(userkey, strconv.Itoa(one.Uuid))
			}

		}

	}
	return rt, nil
}

func SaveUserApproveList(uuid int, adduuid int) error {
	userkey := redis.FRIEND_APPROVELIST_KEY + ":" + strconv.Itoa(uuid)
	var finfo ApplyInfo
	finfo.Uuid = adduuid
	finfo.Apply_time = int(time.Now().Unix())
	str, err := json.Marshal(&finfo)
	if err != nil {
		logger.Error("SaveUserApproveList failed,err=%v", err)
	}
	err = redishandler.GetRedisClient().HSet(userkey, strconv.Itoa(adduuid), string(str))
	return err
}

func (alist *ApplyList) InApplyList(uuid int) bool {
	for _, val := range alist.Apply_info {
		if val.Uuid == uuid {
			return true
		}
	}
	return false
}

func GetUserApplyList(uuid int) (*ApplyList, error) {
	rt := new(ApplyList)
	//存储为hset key为 固定key+uuid ,field为被添加者的uuid,fieldW为FriendInfo
	userkey := redis.FRIEND_APPLYLIST_KEY + ":" + strconv.Itoa(uuid)
	vv, err := redishandler.GetRedisClient().HGetAllValues(userkey)
	if err != nil {
		logger.Error("GetUserApplyList err")
		return nil, err
	}

	nowtime := int(time.Now().Unix())
	for _, val := range vv {
		one := new(ApplyInfo)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err != nil {
			//需要剔除超过时间的
			if nowtime <= one.Apply_time+86400 {
				rt.Apply_info = append(rt.Apply_info, *one)
			} else {
				//已经超时，需要删除
				redishandler.GetRedisClient().HDel(userkey, strconv.Itoa(one.Uuid))
			}

		}

	}
	return rt, nil
}

func SaveUserApplyList(uuid int, adduuid int) error {
	userkey := redis.FRIEND_APPLYLIST_KEY + ":" + strconv.Itoa(uuid)
	var finfo ApplyInfo
	finfo.Uuid = adduuid
	finfo.Apply_time = int(time.Now().Unix())
	str, err := json.Marshal(&finfo)
	if err != nil {
		logger.Error("SaveUserApplyList failed,err=%v", err)
	}
	err = redishandler.GetRedisClient().HSet(userkey, strconv.Itoa(adduuid), string(str))
	return err
}

func GetUserFriendList(uuid int) (*FriendList, error) {
	//todo
	rt := new(FriendList)
	//存储为hset key为 固定key+uuid ,field为被添加者的uuid,fieldW为FriendInfo
	userkey := redis.FRIEND_LIST_KEY + ":" + strconv.Itoa(uuid)
	vv, err := redishandler.GetRedisClient().HGetAllValues(userkey)
	if err != nil {
		logger.Error("GetUserFriendList err")
		return nil, err
	}

	for _, val := range vv {
		one := new(FriendInfo)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err != nil {
			rt.Friends = append(rt.Friends, *one)
		}

	}
	return rt, nil
}

func SaveUserFriendList(uuid int, adduuid int, status int) error {
	userkey := redis.FRIEND_LIST_KEY + ":" + strconv.Itoa(uuid)
	var finfo FriendInfo
	finfo.Uuid = adduuid
	finfo.Status = status
	str, err := json.Marshal(&finfo)
	if err != nil {
		logger.Error("SaveUserFriendList failed,err=%v", err)
	}
	err = redishandler.GetRedisClient().HSet(userkey, strconv.Itoa(adduuid), string(str))
	return err
}

//判断是否已经是好友
func (flist *FriendList) IsInFreiendList(uuid int) bool {
	for _, val := range flist.Friends {
		if val.Uuid == uuid && val.Status == 0 {
			return true
		}
	}
	return false
}

func SaveCacheRecommandFriendList(uuid int, data *GetRecommendListDesc) {
	savestr, err := json.Marshal(data)
	if err != nil {
		logger.Error("SaveCacheRecommandFriendList err=%v", err)
		return
	}
	err = redishandler.GetRedisClient().HSet(redis.FRIEND_RECOMMANDLIST_KEY, strconv.Itoa(uuid), string(savestr))
	if err != nil {
		logger.Error("SaveCacheRecommandFriendList err=%v", err)
		return
	}
}

func GetCacheRecommandFriendList(uuid int) (*GetRecommendListDesc, error) {
	rt := new(GetRecommendListDesc)
	val, err := redishandler.GetRedisClient().HGet(redis.FRIEND_RECOMMANDLIST_KEY, strconv.Itoa(uuid))
	if err != nil {
		logger.Error("GetCacheRecommandFriendList err=%v", err)
		return rt, err
	}

	err = json.Unmarshal([]byte(val), rt)
	if err != nil {
		logger.Error("GetCacheRecommandFriendList err=%v", err)
		return nil, err
	}

	return rt, nil
}

func DelCacheRecommandFriendList(uuid int) error {
	err := redishandler.GetRedisClient().HDel(redis.FRIEND_RECOMMANDLIST_KEY, strconv.Itoa(uuid))
	return err
}

func GetFfiendData(frienduuid int) *GetRecommendListInfo {
	tmpext, err := GetUserExt(frienduuid)
	if err != nil {
		return nil
	}
	tmpbasic, err := GetUserBasic(frienduuid)
	if err != nil {
		return nil
	}

	tmpinfo := new(GetRecommendListInfo)
	tmpinfo.Hot = tmpext.Hot
	tmpinfo.Bean = tmpext.Bean
	tmpinfo.Userid = tmpext.Userid
	tmpinfo.Coin = tmpext.Coin
	tmpinfo.Reg_time = tmpext.Regtime
	tmpinfo.Lv = tmpext.Lv
	tmpinfo.Exp = tmpext.Exp
	tmpinfo.Nickname = tmpbasic.User_nickname
	tmpinfo.Avatar_url = tmpbasic.User_avatar_url
	tmpinfo.Cat_num = 0
	tmpinfo.City = tmpbasic.User_city
	tmpinfo.Gender = tmpbasic.User_gender
	tmpinfo.Love_exp = tmpext.Loevexp
	tmpinfo.Shop_num = tmpext.Shopnum
	return tmpinfo
}

//获取推荐好友列表
func (flist *FriendList) GetRecommandFriendList(uuid, friendnum int) (*GetRecommendListDesc, error) {

	rlist, err := GetCacheRecommandFriendList(uuid)
	if err == nil {
		//有缓存 ，直接返回
		return rlist, err
	}

	selfext, err := GetUserExt(uuid)
	if err != nil {
		return nil, err
	}
	selfbasic, err := GetUserBasic(uuid)
	if err != nil {
		return nil, err
	}

	var randlist []int //记录随机的几个好友
	var first []int    //初步筛选的id列表
	var second []int   //第二步
	var third []int
	vv, err := redishandler.GetRedisClient().HGetAllValues(redis.USER_EXT_DATA)
	if err != nil {
		return nil, err
	}

	for _, val := range vv {
		one := new(UserExtData)
		bytestr := val.([]byte)
		err = json.Unmarshal(bytestr, one)
		if err == nil {
			if selfext.Hot <= one.Hot+500 && selfext.Hot >= one.Hot-500 {
				first = append(first, one.User_id)
			}
		}
		if len(randlist) < friendnum {
			randlist = append(randlist, one.User_id)
		}
	}

	applylist, err := GetUserApplyList(uuid)
	if err != nil {
		logger.Error("GetRecommandFriendList failed err=%v", err)
		second = append(second, first...)
	} else {
		//第二步判断是否已经在申请列表,不再才加入
		for _, val := range first {
			if !applylist.InApplyList(val) {
				second = append(second, val)
			}
		}
	}

	//第三步判断性别
	for _, val := range second {
		if len(third) >= friendnum {
			//数量已经满了，直接退出
			break
		}

		tmpbasic, err := GetUserBasic(val)
		if err != nil {
			continue
		}
		if tmpbasic.User_gender != selfbasic.User_gender {
			third = append(third, val)
		}
	}

	//最后判断一下数量是否足够
	if len(third) < friendnum {
		//将随机的id补充进去
		for i := 0; i < friendnum-len(third); i++ {
			third = append(third, randlist[i])
		}
	}

	//最后赋值
	realrt := new(GetRecommendListDesc)
	for _, val := range third {
		tmpext, err := GetUserExt(val)
		if err != nil {
			logger.Error("GetRecommendListDesc third err=%v", err)
			continue
		}
		tmpbasic, err := GetUserBasic(val)
		if err != nil {
			logger.Error("GetRecommendListDesc third err=%v", err)
			continue
		}
		var tmpinfo GetRecommendListInfo
		tmpinfo.Hot = tmpext.Hot
		tmpinfo.Bean = tmpext.Bean
		tmpinfo.Userid = tmpext.Userid
		tmpinfo.Coin = tmpext.Coin
		tmpinfo.Reg_time = tmpext.Regtime
		tmpinfo.Lv = tmpext.Lv
		tmpinfo.Exp = tmpext.Exp
		tmpinfo.Nickname = tmpbasic.User_nickname
		tmpinfo.Avatar_url = tmpbasic.User_avatar_url
		tmpinfo.Cat_num = 0
		tmpinfo.City = tmpbasic.User_city
		tmpinfo.Gender = tmpbasic.User_gender
		tmpinfo.Love_exp = tmpext.Loevexp
		tmpinfo.Shop_num = tmpext.Shopnum
		realrt.Recommend_list = append(realrt.Recommend_list, tmpinfo)

	}

	//保存到缓存
	SaveCacheRecommandFriendList(uuid, realrt)
	return realrt, nil
}

func SaveAccount(account, pwd string) error {
	//首先对pwd加密
	h := md5.New()
	h.Write([]byte(pwd)) // 需要加密的字符串为
	newpwd := hex.EncodeToString(h.Sum(nil))
	err := redishandler.GetRedisClient().HSet(redis.USER_ACCOUNT_PASSWORD_KEY, account, newpwd)
	return err
}

func CheckAccout(account, pwd string) error {
	h := md5.New()
	h.Write([]byte(pwd)) // 需要加密的字符串为
	newpwd := hex.EncodeToString(h.Sum(nil))
	pwdstr, err := redishandler.GetRedisClient().HGet(redis.USER_ACCOUNT_PASSWORD_KEY, account)
	if err != nil {
		return err
	}
	if pwdstr != newpwd {
		return errors.New("pwdword not right!")
	}
	return nil
}

func SaveAccountToken(acc, token string) {
	err := redishandler.GetRedisClient().HSet(redis.USER_ACCOUNT_PASSWORD_KEY, acc, token)
	if err != nil {
		logger.Error("SaveAccountToken err=%v", err)
	}
}

func GetAccountToken(acc string) string {
	token, err := redishandler.GetRedisClient().HGet(redis.USER_ACCOUNT_PASSWORD_KEY, acc)
	if err != nil {
		logger.Error("GetAccountToken failed err=%v", err)
		return ""
	}

	return token
}

type WorkList []InviteWorkDesc

func (wl *WorkList) IsInWork(uuid int) bool {
	isIn := false
	for _, val := range *wl {
		if val.Uuid == uuid {
			isIn = true
		}
	}
	return isIn
}

//此接口为处理返回所有的打工列表
func GetRealDagonglist(uuid int) (*WorkList, *WorkList, error) {
	vv, err := redishandler.GetRedisClient().HGet(redis.USER_INVITEWORK_RELATION, strconv.Itoa(uuid))

	if err != nil {
		//logger.Error("GetdagongList err=%v",err)
		return nil, nil, nil
	}

	var reallist WorkList
	var list WorkList
	err = json.Unmarshal([]byte(vv), &list)
	if err != nil {
		logger.Error("GetRealDagonglist err=%v", err)
		return nil, nil, err
	}

	//此处时间改为600s
	nowtime := int(time.Now().Unix())
	for i := 0; i < len(list); i++ {
		if nowtime > 600+list[i].InviteTime {
			//list = append(list[:i],list[i+1:]...)
			//i--
		} else {
			reallist = append(reallist, list[i])
		}
	}

	return &list, &reallist, nil
}

func GetdagongList(uuid int) (*WorkList, []InviteWorkOffDesc, error) {
	//需要判断 超过时间  四小时的删除
	vv, err := redishandler.GetRedisClient().HGet(redis.USER_INVITEWORK_RELATION, strconv.Itoa(uuid))

	if err != nil {
		//logger.Error("GetdagongList err=%v",err)
		return nil, nil, nil
	}

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

	var offlist []InviteWorkOffDesc
	//此处时间改为600s
	nowtime := int(time.Now().Unix())
	for i := 0; i < len(list); i++ {
		if nowtime > 4*3600+list[i].InviteTime {
			var tmp InviteWorkOffDesc
			tmp.Uuid = list[i].Uuid
			tmp.InviteTime = list[i].InviteTime
			offlist = append(offlist, tmp)
			list = append(list[:i], list[i+1:]...)

			i--

		}
	}

	return &list, offlist, nil
}

//加入打工列表
func AddDagongList(uuid int, masteruuid int, list WorkList) error {

	nickname, headurl, _, err := mysql.QueryNameAndHead(uuid)
	if err != nil {
		logger.Error("AddDagongList err=%v", err)
		return err
	}

	var tmp InviteWorkDesc
	tmp.HeadUrl = headurl
	tmp.Uuid = uuid
	tmp.Nickname = nickname
	tmp.InviteTime = int(time.Now().Unix())

	list = append(list, tmp)

	savestr, err := json.Marshal(&list)
	if err != nil {
		logger.Error("AddDagongList err=%v", err)
		return err
	}

	err = redishandler.GetRedisClient().HSet(redis.USER_INVITEWORK_RELATION, strconv.Itoa(masteruuid), string(savestr))
	if err != nil {
		logger.Error("AddDagongList err=%v", err)
		return err
	}

	return nil
}

//查询玩家现在所在的队伍id
func QueryUserTeamId(uuid int) (int, error) {
	rkey := "cat:cafe:teamuser:where:user_id:" + strconv.Itoa(uuid) + ":status:0"
	teamstr, err := redishandler.GetRedisClient().GetString(rkey)
	if err != nil {
		return 0, err
	}
	var tmp RedisTeamInfo
	err = json.Unmarshal([]byte(teamstr), &tmp)
	if err != nil {
		return 0, nil
	}

	return tmp.Team_id, nil
}

func GetChatEmojInfo(uuid int) *EmojunlockInfo {
	var tmp EmojunlockInfo
	vv, err := redishandler.GetRedisClient().HGet(redis.USER_CHAT_EMOJUNLOCK_KEY, strconv.Itoa(uuid))
	if err != nil {
		//return nil
		//如果还没有则做一个初始化
		tmp.Emojinfo = append(tmp.Emojinfo, 0)
		tmp.Emojinfo = append(tmp.Emojinfo, 0)
		tmp.Emojinfo = append(tmp.Emojinfo, 0)
		tmp.Emojinfo = append(tmp.Emojinfo, 0)
		savestr, err := json.Marshal(&tmp)
		if err != nil {
			logger.Error("GetChatEmojInfo err=%v", err)
		}
		err = redishandler.GetRedisClient().HSet(redis.USER_CHAT_EMOJUNLOCK_KEY, strconv.Itoa(uuid), string(savestr))
		if err != nil {
			logger.Error("GetChatEmojInfo err=%v", err)
		}
		return &tmp
	}
	err = json.Unmarshal([]byte(vv), &tmp)
	if err != nil {
		return nil
	}
	return &tmp
}

func SaveChatEmojInfo(uuid int, save *EmojunlockInfo) error {
	savestr, err := json.Marshal(save)
	if err != nil {
		logger.Error("SaveChatEmojInfo err=%v")
		return err
	}
	err = redishandler.GetRedisClient().HSet(redis.USER_CHAT_EMOJUNLOCK_KEY, strconv.Itoa(uuid), string(savestr))
	if err != nil {
		logger.Error("SaveChatEmojInfo err=%v", err)
		return err
	}
	return nil
}

func CheckTeamHasNewMessage(uuid int) (bool, error) {
	lastteamsec := 0
	lastchatteamsec := 0
	laststr, err := redishandler.GetRedisClient().HGet(redis.USER_CHAT_TEAM_LASTGET_KEY, strconv.Itoa(uuid))
	if err == nil {
		lastteamsec, _ = strconv.Atoi(laststr)
	}

	//先取得玩家队伍id
	teamid, err := QueryUserTeamId(uuid)
	if err != nil {
		return false, nil
	}
	//取出最后一条工会聊天记录
	rteamkey := redis.USER_CHAT_TEAM_INFO_KEY + ":" + strconv.Itoa(teamid)
	chatinfostr, err := redishandler.GetRedisClient().LIndex(rteamkey, 0)
	if err != nil {
		logger.Error("CheckHasNewMessage failed err=%v", err)
	} else {
		var chats ChatInfoDesc
		err = json.Unmarshal([]byte(chatinfostr), &chats)
		if err != nil {
			logger.Error("CheckHasNewMessage failed err=%v", err)
		} else {
			lastchatteamsec = chats.ChatTime
		}
	}

	if lastchatteamsec > lastteamsec {
		//新的聊天信息
		redishandler.GetRedisClient().HSet(redis.USER_CHAT_ISNEW, strconv.Itoa(uuid), "1")
		return true, nil
	}
	return false, nil
}

func GetPrivateBriefList(uuid int) []QueryBrifeMessageData {
	var rtsl []QueryBrifeMessageData
	var talklistuid []int   //所有的聊天列表
	var nonewmesslist []int //没有新消息的列表
	rselfkey := redis.USER_CHAT_PRIVATE_LASTGET_KEY + ":" + strconv.Itoa(uuid)
	vv, err := redishandler.GetRedisClient().HGetAllKeys(rselfkey)
	if err != nil {
		logger.Error("GetPrivateBriefList failed err=%v", err)
		return nil
	}

	for _, val := range vv {
		bytestr := string(val.([]byte))
		bytenum, _ := strconv.Atoi(bytestr)
		talklistuid = append(talklistuid, bytenum)
	}

	for _, val := range talklistuid {
		selfgetsec := 0
		selftalksec := 0
		rkeysselfs := redis.USER_CHAT_PRIVATE_INFO_KEY + ":" + strconv.Itoa(uuid) + ":" + strconv.Itoa(val)
		tmpstr, err := redishandler.GetRedisClient().HGet(rselfkey, strconv.Itoa(uuid))
		if err == nil {
			selfgetsec, _ = strconv.Atoi(tmpstr)
		}

		//查询最后一条记录
		cselfstr, err := redishandler.GetRedisClient().LIndex(rkeysselfs, 0)
		if err == nil {
			var chats ChatInfoDesc
			err = json.Unmarshal([]byte(cselfstr), &chats)
			if err == nil {
				selftalksec = chats.ChatTime
			}
		}

		if selfgetsec < selftalksec {
			var tmp QueryBrifeMessageData
			tmp.Uuid = val
			tmp.Isnew = 1
			tmp.Ctype = 2
			heads, names, _, err := mysql.QueryNameAndHead(val)
			if err != nil {
				logger.Error("GetPrivateBriefList err=%v", err)
			}
			tmp.Nickname = names
			tmp.Headurl = heads
			rtsl = append(rtsl, tmp)
		} else {
			nonewmesslist = append(nonewmesslist, val)
		}
	}

	//如果没有满五个 则从没有新消息的列表取获取
	for _, val := range nonewmesslist {
		if len(rtsl) >= 5 {
			break
		}

		var tmp QueryBrifeMessageData
		tmp.Uuid = val
		tmp.Isnew = 0
		tmp.Ctype = 2
		heads, names, _, err := mysql.QueryNameAndHead(val)
		if err != nil {
			logger.Error("GetPrivateBriefList err=%v", err)
		}
		tmp.Nickname = names
		tmp.Headurl = heads
		rtsl = append(rtsl, tmp)
	}
	return rtsl
}

func CheckHasNewMessage(uuid int) (bool, error) {
	//首先检查工会记录
	isnew, err := CheckTeamHasNewMessage(uuid)
	if err == nil && isnew {
		return true, nil
	}

	//判断自己的私人聊天记录
	var talklistuid []int
	rselfkey := redis.USER_CHAT_PRIVATE_LASTGET_KEY + ":" + strconv.Itoa(uuid)
	vv, err := redishandler.GetRedisClient().HGetAllKeys(rselfkey)
	if err != nil {
		return false, err
	}

	for _, val := range vv {
		bytestr := string(val.([]byte))
		bytenum, _ := strconv.Atoi(bytestr)
		talklistuid = append(talklistuid, bytenum)
	}

	for _, val := range talklistuid {
		selfgetsec := 0
		selftalksec := 0
		rkeysselfs := redis.USER_CHAT_PRIVATE_INFO_KEY + ":" + strconv.Itoa(uuid) + ":" + strconv.Itoa(val)
		tmpstr, err := redishandler.GetRedisClient().HGet(rselfkey, strconv.Itoa(uuid))
		if err == nil {
			selfgetsec, _ = strconv.Atoi(tmpstr)
		}

		//查询最后一条记录
		cselfstr, err := redishandler.GetRedisClient().LIndex(rkeysselfs, 0)
		if err == nil {
			var chats ChatInfoDesc
			err = json.Unmarshal([]byte(cselfstr), &chats)
			if err == nil {
				selftalksec = chats.ChatTime
			}
		}

		if selfgetsec < selftalksec {
			redishandler.GetRedisClient().HSet(redis.USER_CHAT_ISNEW, strconv.Itoa(uuid), "1")
			return true, nil
		}
	}

	return false, nil
}

func GetWorldChatMessage(uuid int) []QueryChatMessageData {
	var rtsl QueryChatMessageDatas
	vvs, err := redishandler.GetRedisClient().LRange(redis.WORLD_CHAT_INFO_KEY, 0, -1)
	if err != nil {
		logger.Error("GetWorldChatMessage err=%v", err)
		return rtsl
	}

	for _, val := range vvs {
		var tmp QueryChatMessageData
		err = json.Unmarshal([]byte(val), &tmp)
		if err == nil {
			rtsl = append(rtsl, tmp)
		}
	}
	sort.Sort(rtsl)
	return rtsl
}

func GetTeamChatMessage(uuid int) []QueryChatMessageData {
	var rtsl QueryChatMessageDatas
	tid, err := QueryUserTeamId(uuid)
	if err != nil {
		logger.Error("GetTeamChatMessage err=%v", err)
		return rtsl
	}
	rkey := redis.USER_CHAT_TEAM_INFO_KEY + ":" + strconv.Itoa(tid)
	vvs, err := redishandler.GetRedisClient().LRange(rkey, 0, -1)
	if err != nil {
		logger.Error("GetTeamChatMessage err=%v", err)
		return rtsl
	}
	for _, val := range vvs {
		var tmp QueryChatMessageData
		err = json.Unmarshal([]byte(val), &tmp)
		if err == nil {
			rtsl = append(rtsl, tmp)
		}
	}
	sort.Sort(rtsl)
	return rtsl
}

func GetPrivateChatMessage(uuid, taduid int) []QueryChatMessageData {
	var rtsl QueryChatMessageDatas
	rkey := redis.USER_CHAT_PRIVATE_INFO_KEY + ":" + strconv.Itoa(uuid) + ":" + strconv.Itoa(taduid)
	vvs, err := redishandler.GetRedisClient().LRange(rkey, 0, -1)
	if err != nil {
		logger.Error("GetPrivateChatMessage err=%v", err)
		return rtsl
	}
	for _, val := range vvs {
		var tmp QueryChatMessageData
		err = json.Unmarshal([]byte(val), &tmp)
		if err == nil {
			rtsl = append(rtsl, tmp)
		}
	}
	sort.Sort(rtsl)
	return rtsl
}

func WorldChat(message string, uuid int) (int, string) {
	length, err := redishandler.GetRedisClient().LLen(redis.WORLD_CHAT_INFO_KEY)
	if err == nil {
		if length >= CHATLIMITNUM {
			//需要先把多余的聊天记录删除
			delcnt := length - CHATLIMITNUM
			for i := 0; i < delcnt; i++ {
				_, err = redishandler.GetRedisClient().RPop(redis.WORLD_CHAT_INFO_KEY)
				if err != nil {
					logger.Error("WorldChat failed err=%v", err)
				}
			}
		}
	}

	//构建新的结构
	var chats QueryChatMessageData
	chats.Message = message
	chats.Uuid = uuid
	chats.Chattime = int(time.Now().Unix())
	name, head, sex, err := mysql.QueryNameAndHead(uuid)
	if err != nil {
		logger.Error("WorldChat err=%v", err)
	}
	chats.Headurl = head
	chats.Nickname = name
	chats.Sex = sex

	savestr, err := json.Marshal(&chats)
	if err != nil {
		logger.Error("WorldChat err=%v", err)
		return 1, "json failed"
	}

	err = redishandler.GetRedisClient().LPush(redis.WORLD_CHAT_INFO_KEY, string(savestr))
	if err != nil {
		logger.Error("WorldChat err=%v", err)
		return 2, "redis failed"
	}
	return 0, "success"
}

func TeamChat(message string, uuid int) (int, string) {
	tid, err := QueryUserTeamId(uuid)
	if err != nil {
		logger.Error("TeamChat err=%v", err)
		return 1, "getteamid failed"
	}
	rkey := redis.USER_CHAT_TEAM_INFO_KEY + ":" + strconv.Itoa(tid)
	length, err := redishandler.GetRedisClient().LLen(rkey)
	if err == nil {
		if length >= CHATLIMITNUM {
			//需要先把多余的聊天记录删除
			delcnt := length - CHATLIMITNUM
			for i := 0; i < delcnt; i++ {
				_, err = redishandler.GetRedisClient().RPop(rkey)
				if err != nil {
					logger.Error("TeamChat failed err=%v", err)
				}
			}
		}
	}

	//构建新的结构
	var chats QueryChatMessageData
	chats.Message = message
	chats.Uuid = uuid
	chats.Chattime = int(time.Now().Unix())
	name, head, sex, err := mysql.QueryNameAndHead(uuid)
	if err != nil {
		logger.Error("TeamChat err=%v", err)
	}
	chats.Headurl = head
	chats.Nickname = name
	chats.Sex = sex

	savestr, err := json.Marshal(&chats)
	if err != nil {
		logger.Error("TeamChat err=%v", err)
		return 1, "json failed"
	}

	err = redishandler.GetRedisClient().LPush(rkey, string(savestr))
	if err != nil {
		logger.Error("TeamChat err=%v", err)
		return 2, "redis failed"
	}
	return 0, ""
}

func PrivateChat(message string, uuid int, taruid int) (int, string) {
	//存入待收人的列表
	rkey := redis.USER_CHAT_PRIVATE_INFO_KEY + ":" + strconv.Itoa(taruid) + ":" + strconv.Itoa(uuid)
	length, err := redishandler.GetRedisClient().LLen(rkey)
	if err == nil {
		if length >= CHATLIMITNUM {
			//需要先把多余的聊天记录删除
			delcnt := length - CHATLIMITNUM
			for i := 0; i < delcnt; i++ {
				_, err = redishandler.GetRedisClient().RPop(rkey)
				if err != nil {
					logger.Error("PrivateChat failed err=%v", err)
				}
			}
		}
	}

	//构建新的结构
	var chats QueryChatMessageData
	chats.Message = message
	chats.Uuid = uuid
	chats.Chattime = int(time.Now().Unix())
	name, head, sex, err := mysql.QueryNameAndHead(uuid)
	if err != nil {
		logger.Error("PrivateChat err=%v", err)
	}
	chats.Headurl = head
	chats.Nickname = name
	chats.Sex = sex

	savestr, err := json.Marshal(&chats)
	if err != nil {
		logger.Error("PrivateChat err=%v", err)
		return 1, "json failed"
	}

	err = redishandler.GetRedisClient().LPush(rkey, string(savestr))
	if err != nil {
		logger.Error("PrivateChat err=%v", err)
		return 2, "redis failed"
	}

	//存入自己的聊天记录
	rkey = redis.USER_CHAT_PRIVATE_INFO_KEY + ":" + strconv.Itoa(uuid) + ":" + strconv.Itoa(taruid)
	length, err = redishandler.GetRedisClient().LLen(rkey)
	if err == nil {
		if length >= CHATLIMITNUM {
			//需要先把多余的聊天记录删除
			delcnt := length - CHATLIMITNUM
			for i := 0; i < delcnt; i++ {
				_, err = redishandler.GetRedisClient().RPop(rkey)
				if err != nil {
					logger.Error("PrivateChat failed err=%v", err)
				}
			}
		}
	}

	err = redishandler.GetRedisClient().LPush(rkey, string(savestr))
	if err != nil {
		logger.Error("PrivateChat err=%v", err)
		return 2, "redis failed"
	}
	return 0, ""
}

func GetRandChatMessage() string {
	index := rand.Int() % len(RandChatList)
	return RandChatList[index]
}

func HandleRandWorldChat() {
	length, err := redishandler.GetRedisClient().LLen(redis.WORLD_CHAT_INFO_KEY)
	if err == nil {
		if length >= CHATLIMITNUM {
			//需要先把多余的聊天记录删除
			delcnt := length - CHATLIMITNUM
			for i := 0; i < delcnt; i++ {
				_, err = redishandler.GetRedisClient().RPop(redis.WORLD_CHAT_INFO_KEY)
				if err != nil {
					logger.Error("WorldChat failed err=%v", err)
				}
			}
		}
	}

	//构建新的结构
	var chats QueryChatMessageData
	chats.Message = GetRandChatMessage()
	chats.Uuid = -1
	chats.Chattime = int(time.Now().Unix())

	chats.Headurl = ""
	chats.Nickname = ""
	chats.Sex = 1

	savestr, err := json.Marshal(&chats)
	if err != nil {
		logger.Error("WorldChat err=%v", err)
	}

	err = redishandler.GetRedisClient().LPush(redis.WORLD_CHAT_INFO_KEY, string(savestr))
	if err != nil {
		logger.Error("WorldChat err=%v", err)
	}
}