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

}