package controller

import (
	"blazing/common/data"
	"blazing/common/data/xmlres"
	"blazing/common/socket/errorcode"

	"blazing/logic/service/fight"
	fightinfo "blazing/logic/service/fight/info"
	"blazing/logic/service/fight/input"
	"blazing/logic/service/player"
	configmodel "blazing/modules/config/model"
	"blazing/modules/config/service"
	"blazing/modules/player/model"

	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/grand"
)

const (
	rewardItemExpPool  = 3
	groupBossSlotLimit = 3
)

// PlayerFightBoss 挑战地图boss
func (Controller) PlayerFightBoss(req *ChallengeBossInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
	if err = p.CanFight(); err != 0 {
		return nil, err
	}

	mapNode := p.GetSpace().GetMatchedMapNode(req.BossId)
	if mapNode == nil {
		return nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}
	bossConfigs, err := loadMapBossConfigs(mapNode)
	if err != 0 {
		return nil, err
	}

	monsterInfo, leadMonsterID, err := buildBossMonsterInfo(mapNode.NodeName, bossConfigs)
	if err != 0 {
		return nil, err
	}

	p.Fightinfo.Status = fightinfo.BattleMode.FIGHT_WITH_NPC
	p.Fightinfo.Mode = fightinfo.BattleMode.MULTI_MODE

	ai := player.NewAI_player(monsterInfo)
	ai.CanCapture = resolveBossCaptureRate(bossConfigs[0].IsCapture, leadMonsterID)
	ai.BossScript = bossConfigs[0].Script
	ai.AddBattleProp(0, 2)

	var fightC *fight.FightC
	fightC, err = startMapBossFight(mapNode, p, ai, func(foi model.FightOverInfo) {
		if mapNode.WinBonusID == 0 {
			return
		}
		if shouldGrantBossWinBonus(fightC, p.Info.UserID, bossConfigs[0], foi) {
			p.SptCompletedTask(mapNode.WinBonusID, 1)
		}
	})
	if err != 0 {
		return nil, err
	}

	return nil, -1
}

func startMapBossFight(
	mapNode *configmodel.MapNode,
	p *player.Player,
	ai *player.AI_player,
	fn func(model.FightOverInfo),
) (*fight.FightC, errorcode.ErrorCode) {
	ourPets := p.GetPetInfo(100)
	oppPets := ai.GetPetInfo(0)
	if mapNode != nil && mapNode.IsGroupBoss != 0 {
		ourSlots := buildGroupBossPetSlots(ourPets, groupBossSlotLimit)
		oppSlots := buildGroupBossPetSlots(oppPets, groupBossSlotLimit)
		if len(ourSlots) > 0 && len(oppSlots) > 0 {
			return fight.NewLegacyGroupFightSingleControllerN(p, ai, ourSlots, oppSlots, fn)
		}
	}
	return fight.NewFight(p, ai, ourPets, oppPets, fn)
}

func buildGroupBossPetSlots(pets []model.PetInfo, slotLimit int) [][]model.PetInfo {
	if len(pets) == 0 {
		return nil
	}

	slots := make([][]model.PetInfo, 0, slotLimit)
	for _, pet := range pets {
		if pet.Hp == 0 {
			continue
		}
		if slotLimit <= 0 {
			slotLimit = 3
		}
		if len(slots) < slotLimit {
			slots = append(slots, []model.PetInfo{pet})
			continue
		}
		break
	}
	if len(slots) == 0 {
		return nil
	}
	var idx int = 0
	for _, pet := range pets[len(slots):] {
		if pet.Hp == 0 {
			continue
		}
		for step := 0; step < len(slots); step++ {
			slotIdx := (idx + step) % len(slots)
			if len(slots[slotIdx]) < 6 {
				slots[slotIdx] = append(slots[slotIdx], pet)
				idx = (slotIdx + 1) % len(slots)
				break
			}
		}
	}
	return slots
}

// OnPlayerFightNpcMonster 战斗野怪
func (Controller) OnPlayerFightNpcMonster(req *FightNpcMonsterInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
	if err = p.CanFight(); err != 0 {
		return nil, err
	}
	if req.Number > 9 {
		return nil, errorcode.ErrorCodes.ErrSystemError
	}

	refPet := p.Data[req.Number]
	monster, monsterInfo, err := buildNpcMonsterInfo(refPet, p.Info.MapID)
	if err != 0 {
		return nil, err
	}

	ai := player.NewAI_player(monsterInfo)
	ai.CanCapture = refPet.IsCapture

	p.Fightinfo.Status = fightinfo.BattleMode.FIGHT_WITH_NPC
	p.Fightinfo.Mode = fightinfo.BattleMode.MULTI_MODE

	_, err = fight.NewFight(p, ai, p.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
		handleNpcFightRewards(p, foi, monster)
	})
	if err != 0 {
		return nil, err
	}

	return nil, -1
}

func loadMapBossConfigs(mapNode *configmodel.MapNode) ([]configmodel.BossConfig, errorcode.ErrorCode) {
	if mapNode == nil || len(mapNode.BossIds) == 0 {
		return nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}

	bossID := mapNode.BossIds[0]
	if len(mapNode.BossIds) > 1 {
		bossID = mapNode.BossIds[grand.Intn(len(mapNode.BossIds))]
	}

	bossConfigs := service.NewBossService().Get(bossID)
	if len(bossConfigs) == 0 {
		return nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}

	return bossConfigs, 0
}

func buildBossMonsterInfo(nodeName string, bossConfigs []configmodel.BossConfig) (*model.PlayerInfo, uint32, errorcode.ErrorCode) {
	monsterInfo := &model.PlayerInfo{Nick: nodeName}
	var leadMonsterID uint32

	for i, bossConfig := range bossConfigs {
		dv, generation := bossFightPetArgs(bossConfig.IsCapture)
		monster := model.GenPetInfo(
			gconv.Int(bossConfig.MonID),
			dv,
			-1,
			0,
			int(bossConfig.Lv),
			nil,
			generation,
		)
		if monster == nil {
			return nil, 0, errorcode.ErrorCodes.ErrPokemonNotExists
		}
		monster.CatchTime = uint32(i)
		monster.ConfigBoss(bossConfig.PetBaseConfig)
		appendPetEffects(monster, bossConfig.Effect)

		if i == 0 {
			leadMonsterID = monster.ID
		}
		monsterInfo.PetList = append(monsterInfo.PetList, *monster)
	}

	if len(monsterInfo.PetList) == 0 {
		return nil, 0, errorcode.ErrorCodes.ErrPokemonNotExists
	}

	if bossConfigs[0].IsCapture == 1 {
		monsterInfo.PetList[0].ShinyInfo = make([]data.GlowFilter, 0)
		if grand.Meet(1, 500) {
			monsterInfo.PetList[0].RandomByWeightShiny()
		}
	}

	return monsterInfo, leadMonsterID, 0
}

func bossFightPetArgs(canCapture int) (dv int, generation int) {
	if canCapture == 1 {
		return -1, -1
	}
	return 24, 0
}

func appendPetEffects(monster *model.PetInfo, effectIDs []uint32) {
	effects := service.NewEffectService().Args(effectIDs)
	for _, effect := range effects {
		monster.EffectInfo = append(monster.EffectInfo, model.PetEffectInfo{
			Idx:  uint16(effect.ID),
			EID:  gconv.Uint16(effect.Eid),
			Args: gconv.Ints(effect.Args),
		})
	}
}

func resolveBossCaptureRate(canCapture int, petID uint32) int {
	if canCapture == 0 {
		return 0
	}

	petCfg, ok := xmlres.PetMAP[int(petID)]
	if !ok || petCfg.CatchRate == 0 {
		return 0
	}

	return petCfg.CatchRate
}

func shouldGrantBossWinBonus(fightC *fight.FightC, playerID uint32, bossConfig configmodel.BossConfig, foi model.FightOverInfo) bool {
	if len(bossConfig.Rule) == 0 {
		return foi.Reason == 0 && foi.WinnerId == playerID
	}

	for _, ruleConfig := range service.NewFightRuleService().GetByRuleIdxs(bossConfig.Rule) {
		rule := input.GetRule(int64(ruleConfig.RuleIdx))
		if rule == nil {
			continue
		}
		rule.SetArgs(ruleConfig.Args...)
		if !rule.Exec(fightC, &foi) {
			return false
		}
	}

	return true
}

func buildNpcMonsterInfo(refPet player.OgrePetInfo, mapID uint32) (*model.PetInfo, *model.PlayerInfo, errorcode.ErrorCode) {
	if refPet.ID == 0 {
		return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}

	monster := model.GenPetInfo(
		refPet.GetID(),
		-1,
		-1,
		0,
		refPet.GetLevel(),
		refPet.ShinyInfo,
		-1,
	)
	if monster == nil {
		return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}
	monster.CatchMap = mapID
	if refPet.Ext != 0 && grand.Meet(1, 500) {
		monster.RandomByWeightShiny()
	}

	petCfg, ok := xmlres.PetMAP[int(monster.ID)]
	if !ok {
		return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
	}

	monsterInfo := &model.PlayerInfo{
		Nick:    petCfg.DefName,
		PetList: []model.PetInfo{*monster},
	}
	return monster, monsterInfo, 0
}

func handleNpcFightRewards(p *player.Player, foi model.FightOverInfo, monster *model.PetInfo) {
	if foi.Reason != 0 || foi.WinnerId != p.Info.UserID || !p.CanGet() {
		return
	}

	petCfg, ok := xmlres.PetMAP[int(monster.ID)]
	if !ok {
		return
	}

	exp := uint32(petCfg.YieldingExp) * monster.Level / 7
	addlevel, poolevel := p.CanGetExp()
	addexp := gconv.Float32(addlevel * gconv.Float32(exp))
	poolexp := gconv.Float32(poolevel) * gconv.Float32(exp)
	rewards := &fightinfo.S2C_GET_BOSS_MONSTER{}

	p.ItemAdd(3, int64(poolexp+addexp))
	rewards.AddItem(rewardItemExpPool, uint32(poolexp))
	p.AddPetExp(foi.Winpet, int64(addexp))

	if p.CanGetItem() {
		itemID := p.GetSpace().GetDrop()
		if itemID != 0 {
			count := uint32(grand.N(1, 2))
			if p.ItemAdd(itemID, int64(count)) {
				rewards.AddItem(uint32(itemID), count)
			}
		}
	}

	petType := int64(petCfg.Type)
	if monster.IsShiny() && p.CanGetXUAN() && petType < 16 {
		xuanID := uint32(400686 + petType)
		count := uint32(grand.N(1, 2))
		if p.ItemAdd(int64(xuanID), int64(count)) {
			rewards.AddItem(xuanID, count)
		}
	}

	if rewards.HasReward() {
		p.SendPackCmd(8004, rewards)
	}
	foi.Winpet.AddEV(petCfg.YieldingEVValues)
}