package logic

import (
	"HttpServer/jsonconf"
	"HttpServer/redishandler"
	"common/logger"
	"common/redis"
	"encoding/json"
	"math/rand"
	"sort"
	"strconv"
	"time"
)

//加红包接口
func (u *UserData) AddRedPackect(num float32) {
	//todo 接后台
	u.Redbag += num
}

//清空一个位置的猫
func (u *UserData) CleadPos(pos int) {
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return
	}

	u.PosInfo[pos].Cat = 0
	u.PosInfo[pos].Position = pos
	u.PosInfo[pos].StartTime = 0
	u.PosInfo[pos].RedPacket = 0
	u.PosInfo[pos].Time = 0
}

//设置一个位置的猫
func (u *UserData) SetCatPos(pos int, catlv, time int, redpack float32, starttime int) {
	if pos < 0 || pos >= len(u.PosInfo) {
		logger.Error("CleadPos failed pos=%v,posinfo=%v", pos, u.PosInfo)
		return
	}

	u.PosInfo[pos].Cat = catlv
	u.PosInfo[pos].Position = pos
	u.PosInfo[pos].StartTime = starttime
	u.PosInfo[pos].RedPacket = redpack
	u.PosInfo[pos].Time = time
}

//获取所有分红猫列表的位置
func (u *UserData) GetLimitCatList() []int {
	var rtlist []int
	for k, v := range u.PosInfo {
		if v.Cat > 36 {
			rtlist = append(rtlist, k)
		}
	}

	return rtlist
}

//根据猫等级获得位置
func (u *UserData) GetCatPos(catlv int) int {
	pos := -1
	for _, v := range u.PosInfo {
		if v.Cat == catlv {
			pos = v.Position
		}
	}

	if pos < 0 || pos >= len(u.PosInfo) {
		pos = -1
	}
	return pos
}

func (u *UserData) HandlePassDay() {
	isdiffday := false
	nowtime := time.Now()
	lasttime := time.Unix(int64(u.LastLoginTime), 0)
	nowdaynum := time.Now().Day()
	lastdaynum := time.Unix(int64(u.LastLoginTime), 0).Day()
	nowtimestamp := time.Date(nowtime.Year(), nowtime.Month(), nowtime.Day(), 0, 0, 0, 0, nowtime.Location())
	lasttimestamp := time.Date(lasttime.Year(), lasttime.Month(), lasttime.Day(), 0, 0, 0, 0, lasttime.Location())

	logger.Info("HandlePassDay lasttime=%v,lasttimestamp=%v", lasttime, lasttimestamp)
	if nowdaynum == lastdaynum {
		//同一天
		if int64(u.LastLoginTime)-time.Now().Unix() > 86400 {
			//已经过了很多天了

			isdiffday = true
		} else {
			//t同一天 不做处理
		}
	} else {
		//不是同一天了
		isdiffday = true
		if nowtimestamp.Unix() != lasttimestamp.Unix()+86400 {

		} else {

		}
		logger.Info("HandlePassDay now=%v,last=%v", nowtimestamp.Unix(), lasttimestamp.Unix())
	}

	if isdiffday {
		//跨天了
		u.DoubleLeftTimes = ACCGOLDRATELIMIT
		u.GetWatchAdsGoldTime = WATCHADSGOLDLIMIT
	}

	u.LastLoginTime = int(nowtime.Unix())

	SaveUserInfo(u, strconv.Itoa(u.UserId))
}

func SaveUserInfo(data *UserData, uniqueid string) error {

	savestr, err := json.Marshal(data)
	if err != nil {
		return err
	}

	err = redishandler.GetRedisClient().HSet(redis.USER_INFO__KEY, uniqueid, string(savestr))

	return err
}

func GetUserInfo(uid string) (*UserData, error) {

	data, err := redishandler.GetRedisClient().HGet(redis.USER_INFO__KEY, uid)
	if err != nil {
		return nil, err
	}
	var tmp UserData
	err = json.Unmarshal([]byte(data), &tmp)
	if err != nil {
		return nil, err
	}

	return &tmp, nil
}

//初始化玩家信息
func InitUserInfo(data *UserLoginReq, resp *UserLoginResp, uuid int) {
	udata := new(UserData)
	udata.UserId = data.UserId
	udata.Gold = 0
	udata.GoldSum += udata.Gold
	udata.Love = 0
	udata.InviteId = data.Fromid
	udata.Highestlv = 0
	udata.CurBoxLv = 1
	udata.IsDouble = 0
	udata.IsAuto = 0
	udata.IsBoxAcc = 0
	udata.RandGiftDay = time.Now().Day()
	udata.RandGiftNum = 6
	udata.RandGiftTime = int(time.Now().Unix())
	udata.Redbag = 0
	udata.IsFirstRedBgCat = 0
	udata.DoubleLeftTimes = ACCGOLDRATELIMIT
	udata.GetWatchAdsGoldTime = WATCHADSGOLDLIMIT
	udata.RegTime = int(time.Now().Unix())
	udata.LastLoginTime = int(time.Now().Unix())

	//初始化16个猫爬架
	for i := 0; i < 16; i++ {
		var d1 CatPosInfo
		d1.Position = i
		d1.Cat = 0
		if i < 5 {
			d1.Cat = 36
		}
		udata.PosInfo = append(udata.PosInfo, d1)
		var d2 DataDesc
		d2.Pos = i
		d2.Catlv = 0

	}
	udata.Goldrate = 0
	udata.Loverate = 0

	//初始化商店信息
	initcatcfg := jsonconf.GetCatConfig(1)
	if initcatcfg == nil {
		logger.Error("get 1catcfg err")
		return
	}
	var info BuyCatInfoData
	info.Buytime = 0
	info.CurPrice, _ = strconv.ParseInt(initcatcfg.Price, 10, 64)
	info.IsMaxBuytime = 0
	udata.BuyCatInfo = append(udata.BuyCatInfo, info)

	//初始化猫咖门店数据
	udata.CatShopInfo.LeftTime = 0
	udata.CatShopInfo.Chapter = 1
	udata.CatShopInfo.DayNum = time.Now().Day()
	udata.CatShopInfo.IsPlaying = 0
	udata.CatShopInfo.PlayTimes = 0
	udata.CatShopInfo.Section = 1
	udata.CatShopInfo.ThisIsWatch = 0
	udata.CatShopInfo.TotalWatchNumLeft = 8 //

	logger.Info("Init user data=%v", udata)

	resp.Data.Nickname = udata.NickName
	resp.Data.UserId = strconv.Itoa(udata.UserId)
	resp.Data.AccessToken = ""
	resp.Data.HeadImg = udata.Head
	resp.Data.LoginType = data.Lype

	//保存redis
	SaveUserInfo(udata, strconv.Itoa(uuid))

	//初始化玩家仓库信息
	pware := new(UserWareHouseData)
	for i := 0; i < 15; i++ {
		var tmp WareHouseDesc
		tmp.Warelv = 0
		pware.Info = append(pware.Info, tmp)
	}
	wares, err := json.Marshal(pware)
	if err != nil {
		logger.Info("InitUserInfo warehouse failed err=%v", err)
	}
	redishandler.GetRedisClient().HSet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(uuid), string(wares))

	//保存此次计算时间
	nowtimestr := strconv.Itoa(int(time.Now().Unix()))
	redishandler.GetRedisClient().HSet(redis.USER_LAST_CALC_TIME, strconv.Itoa(uuid), nowtimestr)
}

//计算购买后猫箱子的位置，将箱子放到对应位置 返回值表示位置 -1表示失败都满了
func getCatPutPos(uinfo *UserData, clv int) int {
	pos := -1
	for k, v := range uinfo.PosInfo {
		if v.Cat == 0 {
			uinfo.PosInfo[k].Cat = clv
			uinfo.PosInfo[k].Position = k
			//v.Catlv = clv
			//v.Pos = k
			pos = k
			break
		}
	}
	return pos
}

//处理红包猫自动合成
func DoAutoMergeRedCat(uinfo *UserData, uuid int) {
	return //需要主动请求
	//首先处理五方招财猫逻辑
	eastsum := 0
	westsum := 0
	southsum := 0
	northsum := 0
	middlesum := 0

	for _, v := range uinfo.PosInfo {
		if v.Cat == 103 {
			eastsum++
		}
		if v.Cat == 104 {
			westsum++
		}
		if v.Cat == 105 {
			southsum++
		}
		if v.Cat == 106 {
			northsum++
		}
		if v.Cat == 107 {
			middlesum++
		}

	}

	//五方猫
	if eastsum > 0 && westsum > 0 && northsum > 0 && southsum > 0 && middlesum > 0 {
		//合成一天招财猫
		//首先去除五只猫
		onepos := -1
		for k, v := range uinfo.PosInfo {
			if v.Cat == 103 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 104 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 105 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 106 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		for k, v := range uinfo.PosInfo {
			if v.Cat == 107 {
				onepos = k
				uinfo.PosInfo[k].Cat = 0
				uinfo.PosInfo[k].RedPacket = 0
				uinfo.PosInfo[k].Position = k
				break
			}
		}
		if onepos < 0 {
			logger.Error("DoAutoMergeRedCat failed onepos=%v", onepos)
		}
		uinfo.PosInfo[onepos].Cat = 102 //1天招财猫
		cfg := jsonconf.GetRedCatConfig(uinfo.PosInfo[onepos].Cat)
		if cfg == nil {
			logger.Error("DoAutoMergeRedCat getrdcfg failed lv=%v", uinfo.PosInfo[onepos].Cat)
		} else {
			uinfo.PosInfo[onepos].Time = 24 * 60 * 60
			uinfo.PosInfo[onepos].RedPacket = cfg.Money
			uinfo.PosInfo[onepos].StartTime = int(time.Now().Unix())
			uinfo.PosInfo[onepos].Position = onepos
		}

	}

}

//合成红包猫 返回红包猫等级 等级为red_catconfig的id+100
func MergeRedBagCat(uinfo *UserData, pos int) int {
	rtpos := 0

	//走随机合成逻辑
	sumrate := float32(0)
	for _, v := range jsonconf.GetJsonConf().RedCatConfig {
		sumrate += v.Rate
	}
	rand.Seed(time.Now().UnixNano())
	randnum := rand.Intn(100)
	tmprate := 0
	for _, v := range jsonconf.GetJsonConf().RedCatConfig {
		tmprate += int(v.Rate / sumrate)
		if tmprate >= randnum {
			uinfo.PosInfo[pos].Position = pos
			uinfo.PosInfo[pos].Cat = 100 + v.Id
			if v.Id == 13 {
				uinfo.PosInfo[pos].Time = 10 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			if v.Id == 14 {
				uinfo.PosInfo[pos].Time = 15 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			if v.Id == 2 {
				uinfo.PosInfo[pos].Time = 24 * 60 * 60
				uinfo.PosInfo[pos].StartTime = int(time.Now().Unix())
			}
			uinfo.PosInfo[pos].RedPacket = v.Money
			rtpos = pos
			break
		}
	}

	return rtpos
}

func (uinfo *UserData) CheckBuyCatSHop() {
	//检查可购买的猫是否会增加
	//需要扩充一下商店
	curshoplv := len(uinfo.BuyCatInfo)
	if uinfo.Highestlv-5 > curshoplv {
		var info BuyCatInfoData
		info.Buytime = 0
		cafcfg := jsonconf.GetCatConfig(uinfo.Highestlv - 5)
		if cafcfg != nil {
			info.CurPrice, _ = strconv.ParseInt(cafcfg.Price, 10, 64)
		}
		info.IsMaxBuytime = 0
		uinfo.BuyCatInfo = append(uinfo.BuyCatInfo, info)
	}
}

func (udata *UserData) CalcGoldRate() int64 {
	//计算出所有速率的和
	//计算方式为 首先计算合成界面猫的产出速率，然后计算红毛包的产出速率，最后计算仓库中的猫的产出速率
	var sumrate int64
	cfg37 := jsonconf.GetCatConfig(37)
	if cfg37 == nil {
		logger.Error("37cfg err!!")
		return 0
	}
	for _, v := range udata.PosInfo {
		if v.Cat > 0 && v.Cat < 100 {
			//有猫存在的要计算一下
			//非红包猫
			for _, vv := range jsonconf.GetJsonConf().CatConfig {
				if vv.Id == v.Cat {
					onerate, _ := strconv.ParseInt(vv.Gold_get, 10, 64)
					sumrate += onerate
					break
				}
			}
		}

		if v.Cat > 100 {
			//红包猫  需要判断是否产金币
			rcfg := jsonconf.GetRedCatConfig(v.Cat)
			if rcfg != nil {
				if rcfg.Is_37 != 0 {
					onerate, _ := strconv.ParseInt(cfg37.Gold_get, 10, 64)
					sumrate += onerate
				}
			} else {
				logger.Error("GetRedCatConfig failed lv=%v", v.Cat)
			}
		}
	}

	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(udata.UserId))
	if err != nil {
		logger.Error("CalcGoldRate failed err=%v", err)
		return sumrate
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcGoldRate Unmarshal redis failed ")
		return sumrate
	}
	for _, v := range wdata.Info {
		if v.Warelv == 0 {
			continue
		}
		rcfg := jsonconf.GetRedCatConfig(v.Warelv + 100)
		if rcfg != nil {
			if rcfg.Is_37 != 0 {
				onerate, _ := strconv.ParseInt(cfg37.Gold_get, 10, 64)
				sumrate += onerate
			}
		} else {
			logger.Error("GetRedCatConfig failed lv=%v", v.Warelv+100)
		}
	}

	udata.Goldrate = sumrate
	return sumrate
}

//发生金币变动时保存排行榜
func (udata *UserData) AddToRank() error {
	err := redishandler.GetRedisClient().Zadd(redis.USER_GOLD_RANK, float64(udata.Gold), strconv.Itoa(udata.UserId))
	if err != nil {
		logger.Error("AddToRank failed err=%v", err)
	}
	return err
}

//计算最高等级猫的名字
func (u *UserData) CalcHigestCatName() string {
	higestlv := 0
	for _, val := range u.PosInfo {
		if higestlv < val.Cat {
			higestlv = val.Cat
		}
	}

	//计算仓库内的
	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(u.UserId))
	if err != nil {
		logger.Error("CalcHigestCatName failed err=%v", err)
		return ""
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcHigestCatName Unmarshal redis failed ")
		return ""
	}
	for _, val := range wdata.Info {
		reallv := val.Warelv + 100
		if higestlv < reallv {
			higestlv = reallv
		}
	}

	//计算猫名字
	if higestlv > 100 {
		cfg := jsonconf.GetRedCatConfig(higestlv - 100)
		if cfg == nil {
			logger.Error("CalcHigestCatName failed getcfg higestlv=%v", higestlv)
			return ""
		}
		return cfg.Name
	} else {
		cfg := jsonconf.GetCatConfig(higestlv)
		if cfg == nil {
			logger.Error("CalcHigestCatName failed getcfg higestlv=%v", higestlv)
			return ""
		}
		return cfg.Name
	}

}

//获取红包猫列表
func (u *UserData) GetRedCatIdList() []int {
	var rtsl []int
	for _, val := range u.PosInfo {
		if val.Cat > 100 {
			rtsl = append(rtsl, val.Cat-100)
		}
	}

	udatastr, err := redishandler.GetRedisClient().HGet(redis.USER_WAREHOUSE_INFO, strconv.Itoa(u.UserId))
	if err != nil {
		logger.Error("CalcGoldRate failed err=%v", err)
		return rtsl
	}
	wdata := new(UserWareHouseData)
	err = json.Unmarshal([]byte(udatastr), wdata)
	if err != nil {
		logger.Error("CalcGoldRate Unmarshal redis failed ")
		return rtsl
	}
	for _, val := range wdata.Info {
		rtsl = append(rtsl, val.Warelv)
	}

	if len(rtsl) > 16 {
		sort.Ints(rtsl)
		return rtsl[:len(rtsl)-16]
	} else {
		return rtsl
	}

}