package logic

import (
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"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
}