package logic

import (
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"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) (*UserExtData,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(UserExtData)
	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 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) error {
	userkey := redis.FRIEND_LIST_KEY + ":" + strconv.Itoa(uuid)
	var finfo FriendInfo
	finfo.Uuid = adduuid
	finfo.Status = 0
	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
}