package game

import (
	"fmt"
	activityCfg "server/conf/activity"
	catnipCfg "server/conf/catnip"
	champshipCfg "server/conf/champship"
	dailyTaskCfg "server/conf/daily_task"
	guesscolorCfg "server/conf/guess_color"
	languageCfg "server/conf/language"
	miningCfg "server/conf/mining"
	orderCfg "server/conf/order"
	passCfg "server/conf/pass"
	raceCfg "server/conf/race"
	"server/game/mod/activity"
	"server/game/mod/item"
	"server/game/mod/mail"
	GoUtil "server/game_util"
	"server/msg"

	"gitea.bywaystudios.com/pet_home/leaf/log"
)

// 活动模块 登录
func (p *Player) ActivityLogin() {
	ItemMod := p.PlayMod.getItemMod()
	// 通用登录处理：检查旧Activity道具并通过邮件退还
	handleSimpleLogin := func(actType int, loginFn func(int) int) {
		ActivityId := p.GetActivityId(actType)
		OldId := loginFn(ActivityId)
		if OldId == 0 {
			return
		}
		var ItemId int
		switch actType {
		case activity.ACT_TYPE_MINING:
			ItemId = miningCfg.GetActivityItemId(OldId)
		case activity.ACT_TYPE_GUESS_COLOR:
			ItemId = guesscolorCfg.GetActivityItemId(OldId)
		case activity.ACT_TYPE_RACE:
			ItemId = raceCfg.GetCoin(OldId)
		case activity.ACT_TYPE_PASS:
			ItemId = passCfg.GetActivityItemId(OldId)
		default:
			return
		}
		ItemNum := ItemMod.GetItem(ItemId)
		if ItemNum != 0 {
			ItemMod.AddItem(ItemId, -ItemNum)
			p.SendActivityMail(item.ITEM_ENERGY_ID, ItemNum, OldId, nil)
		}
	}

	// 挖矿
	handleSimpleLogin(activity.ACT_TYPE_MINING, p.PlayMod.getMiningMod().Login)
	// 猜颜色
	handleSimpleLogin(activity.ACT_TYPE_GUESS_COLOR, p.PlayMod.getGuessColorMod().Login)
	// 赛跑
	handleSimpleLogin(activity.ACT_TYPE_RACE, p.PlayMod.getRaceMod().Login)
	// 猫草大作战
	catnipActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
	CatnipMod := p.PlayMod.getCatnipMod()
	oldId, catnipUnReward := CatnipMod.Login(catnipActivityId)
	if oldId != 0 && len(catnipUnReward) > 0 {
		// 清空猫草大作战数据无需发邮件
		MailMod := p.PlayMod.getMailMod()
		MailMod.SendMail(&mail.MailStruct{
			Title:          languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, "backend_gardenend_mail_title"),
			TitleEn:        languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, "backend_gardenend_mail_title"),
			Content:        languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, "backend_gardenend_mail_content"),
			ContentEn:      languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, "backend_gardenend_mail_content"),
			TitlePtBr:      languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, "backend_gardenend_mail_title"),
			ContentPtBr:    languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, "backend_gardenend_mail_content"),
			TitleEsLatam:   languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_title"),
			ContentEsLatam: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_content"),
			Items:          catnipUnReward,
			Type:           mail.MAIL_TYPE_NORMAL,
		})
	}

	// 通行证
	passActivityId := p.GetActivityId(activity.ACT_TYPE_PASS)
	PassMod := p.PlayMod.getPassMod()
	passOldId := PassMod.Login(passActivityId)
	if passOldId != 0 {
		ItemId := passCfg.GetActivityItemId(passOldId)
		ItemNum := PassMod.Num
		RewardItems, _ := PassMod.GetRewardItems()
		if ItemNum != 0 {
			ItemMod.AddItem(ItemId, -ItemNum)
			p.SendActivityMail(ItemId, ItemNum, passActivityId, RewardItems)
		}
	}
	// 初始化活动道具
	initItem := p.GetMiningMod().GetInitItem()
	if len(initItem) > 0 {
		err := p.HandleItem(initItem, "")
		if err != nil {
			log.Debug("ActivityLogin initItem err : %s", err)
		}
	}

}

// 发送活动邮件
func (p *Player) SendActivityMail(ItemId, ItemNum, ActivityId int, RewardItems []*item.Item) {
	MailMod := p.PlayMod.getMailMod()
	activity_title_key, mail_title_key, mail_content_key := activityCfg.GetActivityRecycleMail(ActivityId)
	activity_title_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, activity_title_key)
	activity_title_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, activity_title_key)
	activity_title_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, activity_title_key)
	activity_title_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, activity_title_key)
	mt_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_title_key)
	mc_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_content_key)
	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_title_key)
	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_content_key)
	mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_title_key)
	mc_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_content_key)
	mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_title_key)
	mc_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_content_key)
	Items := []*item.Item{item.NewItem(ItemId, ItemNum)}
	Items = append(Items, RewardItems...)
	MailMod.SendMail(&mail.MailStruct{
		Title:          fmt.Sprintf(mt_zh, activity_title_zh),
		Content:        fmt.Sprintf(mc_zh, activity_title_zh),
		TitleEn:        fmt.Sprintf(mt_en, activity_title_en),
		ContentEn:      fmt.Sprintf(mc_en, activity_title_en),
		TitlePtBr:      fmt.Sprintf(mt_pt, activity_title_pt),
		ContentPtBr:    fmt.Sprintf(mc_pt, activity_title_pt),
		TitleEsLatam:   fmt.Sprintf(mt_es, activity_title_es),
		ContentEsLatam: fmt.Sprintf(mc_es, activity_title_es),
		Items:          Items,
		Type:           mail.MAIL_TYPE_NORMAL,
	})
}

// 发送活动邮件
func (p *Player) SendActivityMail2(items []*item.Item, mail_title, mail_content string) {
	MailMod := p.PlayMod.getMailMod()
	mt_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_title)
	mc_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_content)
	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_title)
	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_content)
	mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_title)
	mc_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_content)
	mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_title)
	mc_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_content)
	MailMod.SendMail(&mail.MailStruct{
		Title:          mt_zh,
		Content:        mc_zh,
		TitleEn:        mt_en,
		ContentEn:      mc_en,
		TitlePtBr:      mt_pt,
		ContentPtBr:    mc_pt,
		TitleEsLatam:   mt_es,
		ContentEsLatam: mc_es,
		Items:          items,
		Type:           mail.MAIL_TYPE_NORMAL,
	})
}

// 活动模块 零点更新
func (p *Player) ActivityZeroUpdate() {
	p.CatReturnGiftZeroUpdate()
	p.ActivityLogin()
	type zeroHandler struct {
		actType  int
		updateFn func(int)
	}
	handlers := []zeroHandler{
		{activity.ACT_TYPE_MINING, func(id int) { p.PlayMod.getMiningMod().ZeroUpdate(id) }},
		{activity.ACT_TYPE_GUESS_COLOR, func(id int) { p.PlayMod.getGuessColorMod().ZeroUpdate(id) }},
		{activity.ACT_TYPE_RACE, func(id int) { p.PlayMod.getRaceMod().ZeroUpdate(id) }},
		{activity.ACT_TYPE_PASS, func(id int) { p.PlayMod.getPassMod().ZeroUpdate(id) }},
		{activity.ACT_TYPE_CATNIP, func(id int) { p.PlayMod.getCatnipMod().ZeroUpdate(id) }},
	}
	for _, h := range handlers {
		if info := p.GetActivityInfo(h.actType); info != nil {
			h.updateFn(info.Id)
		}
	}
}

// 猫猫回礼0点更新
func (p *Player) CatReturnGiftZeroUpdate() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CAT_RETURN_GIFT)
	var aid int
	var id int
	if activityInfo != nil {
		id = activityInfo.Id
		aid = activityInfo.AId
	}
	oldId, oldScore, oldReward := p.GetCatReturnGiftMod().ZeroUpdate(id, aid)
	if oldId != 0 {
		log.Debug("CatReturnGiftZeroUpdate oldId : %d, oldScore : %d, oldReward : %d", oldId, oldScore, oldReward)
		cfg := G_GameLogicPtr.ActivityMgr.GetCatReturnGiftCfg(oldId)
		items := make([]*item.Item, 0)
		if cfg != nil {
			for _, v := range cfg.RewardList {
				if oldScore >= int(v.Score) && oldReward < int(v.Id) {
					items = append(items, item.MsgToItem(v.Reward)...)
				}
			}
		}
		if len(items) > 0 {
			p.SendActivityMail2(items, "backend_milestone_mail_title", "backend_milestone_mail_content")
		}
	}
}

// 获取活动信息
func (p *Player) GetActivityInfo(actType int) *ActivityInfo {
	for _, v := range p.activity {
		if v.Type == actType {
			return v
		}
	}
	return nil
}

// 获取活动ID
func (p *Player) GetActivityId(actType int) int {
	for _, v := range p.activity {
		if v.Type == actType {
			return v.Id
		}
	}
	return 0
}

// 根据活动ID获取活动信息
func (p *Player) GetActivityInfoById(Id int) *ActivityInfo {
	for _, v := range p.activity {
		if v.Id == Id {
			return v
		}
	}
	return nil
}

// 获取活动状态
func (p *Player) GetActivityStatus(actType int) int {
	activityInfo := p.GetActivityInfo(actType)
	if activityInfo == nil {
		return ACT_STATUS_NOT_START
	}
	now := GoUtil.Now()
	if now < activityInfo.StartT {
		return ACT_STATUS_NOT_START
	}
	if now > activityInfo.EndT {
		return ACT_STATUS_END
	}
	return ACT_STATUS_START
}

// 挖矿活动数据返回
func (p *Player) MiningBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
	if activityInfo == nil {
		return
	}
	status := p.GetActivityStatus(activity.ACT_TYPE_MINING)
	template := miningCfg.GetTemplate(activityInfo.Id)
	DecorateMod := p.PlayMod.getDecorateMod()
	orderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
	passRewardList := miningCfg.GetPassItemList(orderFactor)
	resPassRewardList := make(map[int32]*msg.ItemList)
	for k, v := range passRewardList {
		resPassRewardList[int32(k)] = item.ItemListToMsg(v)
	}
	MiningMod := p.PlayMod.getMiningMod()
	p.PushClientRes(&msg.ResMining{
		Id:         int32(activityInfo.Id),
		Status:     int32(status),
		EndTime:    int32(activityInfo.EndT),
		Template:   int32(template),
		Pass:       int32(MiningMod.GetPass()),
		Gem:        GoUtil.IntToInt32(MiningMod.GetGem()),
		Map:        MiningMod.GetMap(),
		Mining:     int32(MiningMod.GetMining()),
		PassReward: resPassRewardList,
	})
}

// 猜颜色活动数据返回
func (p *Player) GuessColorBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_GUESS_COLOR)
	if activityInfo == nil {
		return
	}

	status := p.GetActivityStatus(activity.ACT_TYPE_GUESS_COLOR)
	GuessColorMod := p.PlayMod.getGuessColorMod()
	mapList := make([]*msg.GuessColorInfo, 0, len(GuessColorMod.MapList))
	for _, v := range GuessColorMod.MapList {
		mapList = append(mapList, &msg.GuessColorInfo{
			Map: v,
		})
	}
	p.PushClientRes(&msg.ResGuessColor{
		Id:      int32(activityInfo.Id),
		Status:  int32(status),
		EndTime: int32(activityInfo.EndT),
		Pass:    int32(GuessColorMod.Pass),
		Opponent: &msg.Opponent{
			Name:     GuessColorMod.Opponent.Name,
			Face:     int32(GuessColorMod.Opponent.Face),
			Avatar:   int32(GuessColorMod.Opponent.Avatar),
			Progress: int32(GuessColorMod.Opponent.Progress),
		},
		WinTime: int32(GuessColorMod.WinTime),
		MapList: mapList,
		OMap:    GuessColorMod.OMap,
	})
}

// 赛跑活动数据返回
func (p *Player) RaceBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_RACE)
	if activityInfo == nil {
		return
	}
	status := p.GetActivityStatus(activity.ACT_TYPE_RACE)
	RaceMod := p.PlayMod.getRaceMod()
	opponent := make([]*msg.Raceopponent, 0, len(RaceMod.Opponent))
	for _, v := range RaceMod.Opponent {
		opponent = append(opponent, &msg.Raceopponent{
			Id:       int32(v.Id),
			Name:     v.Name,
			Face:     int32(v.Face),
			Avatar:   int32(v.Avatar),
			Progress: int32(v.Progress),
		})
	}
	p.PushClientRes(&msg.ResRace{
		Id:            int32(activityInfo.Id),
		Status:        int32(status),
		EndTime:       int32(activityInfo.EndT),
		Pass:          int32(RaceMod.Pass),
		GameStartTime: int32(RaceMod.StartTime),
		Progress:      int32(RaceMod.Progress),
		GameEndTime:   int32(RaceMod.EndTime),
		Opponent:      opponent,
		Rank:          int32(RaceMod.Rank),
	})
}

// 红点数据返回
func (p *Player) RedBackData() {
	result := make(map[int32]int32)
	now := GoUtil.Now()
	for _, v := range p.activity {
		if v.StartT < now && v.EndT > now {
			result[int32(v.Type)] = int32(p.GetRed(v))
		}
	}
	p.PushClientRes(&msg.ResActRed{Red: result})
}

func (p *Player) GetMiningItemId() int {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
	if activityInfo == nil {
		return 0
	}
	return miningCfg.GetActivityItemId(activityInfo.Id)
}

// 通行证活动数据返回
func (p *Player) ActPassBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
	if activityInfo == nil {
		return
	}
	status := p.GetActivityStatus(activity.ACT_TYPE_PASS)
	template := passCfg.GetTemplate(activityInfo.Id)
	PassMod := p.PlayMod.getPassMod()
	p.PushClientRes(&msg.ResActPass{
		Id:       int32(activityInfo.Id),
		Status:   int32(status),
		Template: int32(template),
		EndTime:  int32(activityInfo.EndT),
		LowPass:  PassMod.LowPass > 0,
		HighPass: PassMod.HighPass > 0,
		Score:    int32(PassMod.Num),
		Reward:   GoUtil.IntToInt32(PassMod.Reward),
	})
}

// 获取活动道具
func (p *Player) GetActivityItem(ActType []int) []*item.Item {
	items := make([]*item.Item, 0)
	now := GoUtil.Now()
	for _, v := range ActType {
		activityInfo := p.GetActivityInfo(v)
		if activityInfo == nil {
			continue
		}
		status := ACT_STATUS_START
		if now < activityInfo.StartT {
			status = ACT_STATUS_NOT_START
		} else if now > activityInfo.EndT {
			status = ACT_STATUS_END
		}
		if status != ACT_STATUS_START {
			continue
		}
		switch v {
		case activity.ACT_TYPE_MINING:
			itemInfo := miningCfg.GetLoseItem(activityInfo.Id)
			items = item.Merge(items, itemInfo)
		case activity.ACT_TYPE_GUESS_COLOR:
			itemInfo := guesscolorCfg.GetLoseItem(activityInfo.Id)
			items = item.Merge(items, itemInfo)
		case activity.ACT_TYPE_RACE:
			itemId := raceCfg.GetCoin(activityInfo.Id)
			itemInfo := item.NewItem(itemId, 1)
			items = append(items, itemInfo)
		case activity.ACT_TYPE_PASS:
			itemId := passCfg.GetActivityItemId(activityInfo.Id)
			itemInfo := item.NewItem(itemId, 1)
			items = append(items, itemInfo)
		}
	}
	return items
}

// 猫草大作战活动数据返回
func (p *Player) CatnipBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
	if activityInfo == nil {
		return
	}
	CatnipMod := p.PlayMod.getCatnipMod()
	status := p.GetActivityStatus(activity.ACT_TYPE_CATNIP)
	if CatnipMod == nil {
		return
	}
	FriendMod := p.PlayMod.getFriendMod()
	gameList := make([]*msg.CatnipGame, 0, len(CatnipMod.Game))
	for _, v := range CatnipMod.Game {
		gameInfo := &msg.CatnipGame{
			Id:             int32(v.Id),
			Progress:       int32(v.Progress),
			Status:         int32(v.Status),
			Reward:         GoUtil.SliceIntToInt32(v.Reward),
			Emoji:          int32(v.EmojiId),
			FriendProgress: int32(v.PartnerAdd),
			SendEmoji:      int32(v.SendEmoji),
		}
		if v.Partner != 0 {
			playerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
			if playerData != nil {
				gameInfo.Partner = playerData
			}
		}

		gameList = append(gameList, gameInfo)
	}
	tmpData := make(map[int]*msg.CatnipInvite)
	for uid, info := range CatnipMod.InviteList {
		tmpData[uid] = &msg.CatnipInvite{
			Uid:  int64(uid),
			Time: info.Time,
			Type: 1,
		}
	}
	for uid, info := range CatnipMod.BeInvitedList {
		tmpData[uid] = &msg.CatnipInvite{
			Uid:  int64(uid),
			Time: info.Time,
			Type: 2,
		}
	}

	for uid := range FriendMod.NewFriendList {
		partnerList := p.GetCatnipPartner(uid)
		if len(GoUtil.IntSlice(partnerList)) >= 4 {
			tmpData[uid] = &msg.CatnipInvite{
				Uid:  int64(uid),
				Type: 3,
			}
			continue
		}
		if _, ok := tmpData[uid]; !ok {
			tmpData[uid] = &msg.CatnipInvite{
				Uid:  int64(uid),
				Type: 0,
			}
		}
	}
	for _, v := range CatnipMod.Game {
		if invite, ok := tmpData[v.Partner]; ok {
			invite.Type = 4 // 已参与游戏的好友不显示邀请
		}
	}
	inviteList := make([]*msg.CatnipInvite, 0, len(tmpData))
	for _, v := range tmpData {
		resPlayerSimple := G_getGameLogic().GetResSimplePlayerByUid(int(v.Uid))
		if resPlayerSimple != nil {
			v.Player = resPlayerSimple
		}
		inviteList = append(inviteList, v)
	}

	template := catnipCfg.GetTemplateId(CatnipMod.Id)
	res := &msg.ResCatnip{
		Id:         int32(CatnipMod.Id),
		EndTime:    int32(activityInfo.EndT),
		Status:     int32(status),
		Template:   int32(template),
		GameList:   gameList,
		Multiply:   int32(CatnipMod.Mul),
		FriendList: inviteList,
	}
	p.PushClientRes(res)
}

func (p *Player) GetChampshipActivityId() (int, int) {
	var todayActivityId int
	var yesterdayActivityId int
	activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
	now := GoUtil.Now()
	yesterday := GoUtil.ZeroTimestamp() - 1
	level := p.GetBaseMod().GetLevel()
	champshipActivityIds := champshipCfg.GetChampshipActivityId()
	for _, v := range activiyCfgList {
		if !GoUtil.InArray(v.Id, champshipActivityIds) {
			continue
		}
		if v.Level > level {
			continue
		}
		if v.Startime <= now && v.Endtime >= now {
			todayActivityId = v.Id
		}
		if v.Startime <= yesterday && v.Endtime >= yesterday {
			yesterdayActivityId = v.Id
		}
	}
	return todayActivityId, yesterdayActivityId
}

func (p *Player) GetDailyTaskActivityId() int {
	var activityId int
	activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
	now := GoUtil.Now()
	level := p.GetBaseMod().GetLevel()
	activityIds := dailyTaskCfg.GetActivityIds()
	for _, v := range activiyCfgList {
		if !GoUtil.InArray(v.Type, activityIds) {
			continue
		}
		if v.Level > level {
			continue
		}
		if v.Startime <= now && v.Endtime >= now {
			activityId = v.Id
			break
		}
	}
	return activityId
}

// 猫猫回礼返回
func (p *Player) CatReturnGiftBackData() {
	activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CAT_RETURN_GIFT)
	if activityInfo == nil {
		return
	}
	cfg := G_GameLogicPtr.ActivityMgr.GetCatReturnGiftCfg(activityInfo.Id)
	if cfg == nil {
		return
	}
	CatReturnGiftMod := p.GetCatReturnGiftMod()
	res := &msg.ResCatReturnGift{
		StartTime: activityInfo.StartT,
		EndTime:   activityInfo.EndT,
		Cfg:       cfg,
		Score:     int32(CatReturnGiftMod.GetScore()),
		Reward:    int32(CatReturnGiftMod.GetReward()),
	}
	p.PushClientRes(res)
}