package logic

import (
	"ecs/proto/pb"
	"ecs/servers/game/data"
	"math"
	"slices"
)

func (this *Player) calcHeroLevelAttrs(hero *PlayerHero) (attrs Attrs) {
	var heroLevelTable = this.manager.tables.HeroLevel.Find3(int(hero.Id), int(hero.Level))
	if heroLevelTable != nil {
		attrs[heroLevelTable.AttrType1] = uint64(heroLevelTable.AttrValue1)
		attrs[heroLevelTable.AttrType2] = uint64(heroLevelTable.AttrValue2)
		attrs[heroLevelTable.AttrType3] = uint64(heroLevelTable.AttrValue3)
		attrs[heroLevelTable.AttrType4] = uint64(heroLevelTable.AttrValue4)
		attrs[heroLevelTable.AttrType5] = uint64(heroLevelTable.AttrValue5)
		attrs[heroLevelTable.AttrType6] = uint64(heroLevelTable.AttrValue6)
		attrs[heroLevelTable.AttrType7] = uint64(heroLevelTable.AttrValue7)
		attrs[heroLevelTable.AttrType8] = uint64(heroLevelTable.AttrValue8)
		attrs[heroLevelTable.AttrType9] = uint64(heroLevelTable.AttrValue9)
		attrs[heroLevelTable.AttrType10] = uint64(heroLevelTable.AttrValue10)
	}
	return
}

func (this *Player) calcHeroBreakAttrs(hero *PlayerHero) (attrs Attrs) {
	var heroBreakTable = this.manager.tables.HeroBreak.Find3(int(hero.Id), int(hero.BreakLevel))
	if heroBreakTable != nil {
		attrs[heroBreakTable.AttrType1] = uint64(heroBreakTable.AttrValue1)
		attrs[heroBreakTable.AttrType2] = uint64(heroBreakTable.AttrValue2)
		attrs[heroBreakTable.AttrType3] = uint64(heroBreakTable.AttrValue3)
		attrs[heroBreakTable.AttrType4] = uint64(heroBreakTable.AttrValue4)
		attrs[heroBreakTable.AttrType5] = uint64(heroBreakTable.AttrValue5)
		attrs[heroBreakTable.AttrType6] = uint64(heroBreakTable.AttrValue6)
		attrs[heroBreakTable.AttrType7] = uint64(heroBreakTable.AttrValue7)
		attrs[heroBreakTable.AttrType8] = uint64(heroBreakTable.AttrValue8)
		attrs[heroBreakTable.AttrType9] = uint64(heroBreakTable.AttrValue9)
		attrs[heroBreakTable.AttrType10] = uint64(heroBreakTable.AttrValue10)
	}
	return
}

func (this *Player) calcHeroAwakenAttrs(hero *PlayerHero) (attrs Attrs) {
	return
}

func (this *Player) calcHeroBookAttrs(hero *PlayerHero) (attrs Attrs) {
	var heroBook = this.HeroBook[hero.Id]
	if heroBook == nil {
		return
	}

	for _, item := range heroBook.Items {
		if pb.AbleStatus(item[1]) != pb.AbleStatus_Already {
			continue
		}

		var heroGeneralTable = this.manager.tables.HeroBook.Find1(int(item[0]))
		if heroGeneralTable == nil {
			continue
		}

		attrs[heroGeneralTable.AttrType1] += uint64(heroGeneralTable.AttrValue1)
		attrs[heroGeneralTable.AttrType2] += uint64(heroGeneralTable.AttrValue2)
		attrs[heroGeneralTable.AttrType3] += uint64(heroGeneralTable.AttrValue3)
	}
	return
}

func (this *Player) calcHeroBondAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) (attrs Attrs) {
	if lineup == nil || lineupHero == nil {
		return
	}
	var heroBondTables = this.manager.tables.HeroBond.Find(int(hero.Id))
	for i := range heroBondTables {
		var yes = false
		switch heroBondTables[i].BondType {
		case 1: //装备
			for _, equipUid := range lineupHero.Equip {
				if equipUid == 0 {
					continue
				}
				if equip, ok := this.Equip[equipUid]; ok && slices.Contains(heroBondTables[i].BondId, int(equip.Id)) {
					yes = true
					break
				}
			}
		case 2: //宝物
			for _, treasureUid := range lineupHero.Treasure {
				if treasureUid == 0 {
					continue
				}
				if treasure, ok := this.Treasure[treasureUid]; ok && slices.Contains(heroBondTables[i].BondId, int(treasure.Id)) {
					yes = true
					break
				}
			}
		case 3: //神兵
			for _, artifactUid := range lineupHero.Artifact {
				if artifactUid == 0 {
					continue
				}
				if artifact, ok := this.Artifact[artifactUid]; ok && slices.Contains(heroBondTables[i].BondId, int(artifact.Id)) {
					yes = true
					break
				}
			}
		case 4: //英雄
			var bondIdMap = map[int]struct{}{}
			for _, bondId := range heroBondTables[i].BondId {
				bondIdMap[bondId] = struct{}{}
			}

			for hi := range lineup.Heroes {
				if lineup.Heroes[i] == nil {
					continue
				}

				if another, ok := this.Hero[lineup.Heroes[hi].HeroUid]; ok {
					delete(bondIdMap, int(another.Id))
				}
			}

			for hi := range lineup.Helper {
				if lineup.Helper[hi] == 0 {
					continue
				}

				if helper, ok := this.Hero[lineup.Helper[hi]]; ok {
					delete(bondIdMap, int(helper.Id))
				}
			}

			yes = len(bondIdMap) == 0
		}
		if yes {
			attrs[heroBondTables[i].AttrType1] += uint64(heroBondTables[i].AttrValue1)
			attrs[heroBondTables[i].AttrType2] += uint64(heroBondTables[i].AttrValue2)
			attrs[heroBondTables[i].AttrType3] += uint64(heroBondTables[i].AttrValue3)
		}
	}
	return
}

func (this *Player) calcHeroEquipsAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) (attrs Attrs) {
	if lineup == nil || lineupHero == nil {
		return
	}

	var minLevel uint32
	var minRefineLevel uint32
	var masterTable *data.UpgradeMaster

	minLevel = math.MaxUint32
	var setMap = map[uint32]uint32{}
	for _, equipUid := range lineupHero.Equip {
		if equipUid == 0 {
			continue
		}

		if equip := this.Equip[equipUid]; equip != nil {
			var equipTable = this.manager.tables.Equip.Find1(int(equip.Id))
			if equipTable != nil {
				if equipTable.SetId != 0 {
					setMap[uint32(equipTable.SetId)] += 1
				}
			}

			var equipLevelTable = this.manager.tables.EquipLevel.Find3(int(equip.Id), int(equip.Level))
			if equipLevelTable != nil {
				attrs[equipLevelTable.AttrType] += uint64(equipLevelTable.AttrValue)
			}

			if equip.Level < minLevel {
				minLevel = equip.Level
			}
			if equip.RefineLevel < minRefineLevel {
				minRefineLevel = equip.RefineLevel
			}
		}
	}

	for setId, setCount := range setMap {
		if setCount < 2 {
			continue
		}
		var equipSetTable = this.manager.tables.EquipSet.Find(int(setId))
		if equipSetTable != nil {
			switch setCount {
			case 2:
				if equipSetTable.Set2BuffType != 2 {
					for i := range equipSetTable.Set2BuffArgs {
						attrs[equipSetTable.Set2BuffArgs[i]] += uint64(equipSetTable.Set2BuffVals[i])
					}
				}
			case 3:
				if equipSetTable.Set3BuffType != 2 {
					for i := range equipSetTable.Set3BuffArgs {
						attrs[equipSetTable.Set3BuffArgs[i]] += uint64(equipSetTable.Set3BuffVals[i])
					}
				}
			case 4:
				if equipSetTable.Set4BuffType != 2 {
					for i := range equipSetTable.Set4BuffArgs {
						attrs[equipSetTable.Set4BuffArgs[i]] += uint64(equipSetTable.Set4BuffVals[i])
					}
				}
			}
		}
	}

	masterTable = this.manager.tables.UpgradeMaster.FindMax(int(pb.UpgradeMasterType_MasterEquipUpgrade), int(minLevel))
	if masterTable != nil {
		attrs[masterTable.AttrType1] = uint64(masterTable.AttrValue1)
		attrs[masterTable.AttrType2] = uint64(masterTable.AttrValue2)
		attrs[masterTable.AttrType3] = uint64(masterTable.AttrValue3)
		attrs[masterTable.AttrType4] = uint64(masterTable.AttrValue4)
		attrs[masterTable.AttrType5] = uint64(masterTable.AttrValue5)
		attrs[masterTable.AttrType6] = uint64(masterTable.AttrValue6)
	}

	masterTable = this.manager.tables.UpgradeMaster.FindMax(int(pb.UpgradeMasterType_MasterEquipUpgrade), int(minRefineLevel))
	if masterTable != nil {
		attrs[masterTable.AttrType1] = uint64(masterTable.AttrValue1)
		attrs[masterTable.AttrType2] = uint64(masterTable.AttrValue2)
		attrs[masterTable.AttrType3] = uint64(masterTable.AttrValue3)
		attrs[masterTable.AttrType4] = uint64(masterTable.AttrValue4)
		attrs[masterTable.AttrType5] = uint64(masterTable.AttrValue5)
		attrs[masterTable.AttrType6] = uint64(masterTable.AttrValue6)
	}
	return
}

func (this *Player) calcHeroTreasuresAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) (attrs Attrs) {
	if lineup == nil || lineupHero == nil {
		return
	}

	var minLevel uint32
	var minRefineLevel uint32
	var masterTable *data.UpgradeMaster

	minLevel = math.MaxUint32
	for _, treasureUid := range lineupHero.Treasure {
		if treasureUid == 0 {
			continue
		}

		if treasure := this.Treasure[treasureUid]; treasure != nil {
			var treasureLevelTable = this.manager.tables.TreasureLevel.Find3(int(treasure.Id), int(treasure.Level))
			if treasureLevelTable != nil {
				attrs[treasureLevelTable.AttrType] += uint64(treasureLevelTable.AttrValue)
			}

			if treasure.Level < minLevel {
				minLevel = treasure.Level
			}
			if treasure.RefineLevel < minRefineLevel {
				minRefineLevel = treasure.RefineLevel
			}
		}
	}

	masterTable = this.manager.tables.UpgradeMaster.FindMax(int(pb.UpgradeMasterType_MasterTreasureUpgrade), int(minLevel))
	if masterTable != nil {
		attrs[masterTable.AttrType1] = uint64(masterTable.AttrValue1)
		attrs[masterTable.AttrType2] = uint64(masterTable.AttrValue2)
		attrs[masterTable.AttrType3] = uint64(masterTable.AttrValue3)
		attrs[masterTable.AttrType4] = uint64(masterTable.AttrValue4)
		attrs[masterTable.AttrType5] = uint64(masterTable.AttrValue5)
		attrs[masterTable.AttrType6] = uint64(masterTable.AttrValue6)
	}

	masterTable = this.manager.tables.UpgradeMaster.FindMax(int(pb.UpgradeMasterType_MasterTreasureRefine), int(minRefineLevel))
	if masterTable != nil {
		attrs[masterTable.AttrType1] = uint64(masterTable.AttrValue1)
		attrs[masterTable.AttrType2] = uint64(masterTable.AttrValue2)
		attrs[masterTable.AttrType3] = uint64(masterTable.AttrValue3)
		attrs[masterTable.AttrType4] = uint64(masterTable.AttrValue4)
		attrs[masterTable.AttrType5] = uint64(masterTable.AttrValue5)
		attrs[masterTable.AttrType6] = uint64(masterTable.AttrValue6)
	}
	return
}

func (this *Player) calcHeroMountsAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) (attrs Attrs) {
	if lineup == nil || lineupHero == nil {
		return
	}
	return
}

func (this *Player) calcHeroArtifactAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) (attrs Attrs) {
	if lineup == nil || lineupHero == nil {
		return
	}
	return
}

func (this *Player) calcHeroAttrs(hero *PlayerHero, attrsList ...Attrs) bool {
	var newAttrs Attrs
	for _, attrs := range attrsList {
		for i, attr := range attrs {
			newAttrs[i] += attr
		}
	}

	if newAttrs == hero.attrs {
		return false
	}

	hero.attrs = newAttrs
	return true
}

func (this *Player) updateHeroAttrs(hero *PlayerHero, lineup *PlayerLineup, lineupHero *PlayerLineupHero) bool {
	return this.calcHeroAttrs(hero,
		this.calcHeroLevelAttrs(hero),
		this.calcHeroBreakAttrs(hero),
		this.calcHeroAwakenAttrs(hero),
		this.calcHeroBookAttrs(hero),
		this.calcHeroBondAttrs(hero, lineup, lineupHero),
		this.calcHeroEquipsAttrs(hero, lineup, lineupHero),
		this.calcHeroTreasuresAttrs(hero, lineup, lineupHero),
		this.calcHeroMountsAttrs(hero, lineup, lineupHero),
		this.calcHeroArtifactAttrs(hero, lineup, lineupHero),
	)
}

func (this *Player) UpdateHeroAttrs(hero *PlayerHero) bool {
	if hero == nil {
		return false
	}

	for _, lineup := range this.Lineup {
		if lineup.Active {
			for _, lineupHero := range lineup.Heroes {
				if lineupHero != nil && lineupHero.HeroUid == hero.Uid {
					return this.updateHeroAttrs(hero, lineup, lineupHero)
				}
			}
		}
	}

	return this.updateHeroAttrs(hero, nil, nil)
}