package game

import (
	"fmt"
	"sort"
	"strconv"
	"strings"

	"thehouseoficarus/internal/combat"
	"thehouseoficarus/internal/engine"
	"thehouseoficarus/internal/net"
	"thehouseoficarus/internal/object"
	"thehouseoficarus/internal/player"
	"thehouseoficarus/internal/world"
)

func (g *Game) doAttack(sess *net.Session, input string) {
	p := sess.Player.(*player.Player)

	if combat.GetCombat(p.Name) != nil {
		sess.WriteLine("You are already in combat!")
		return
	}

	if p.Action != nil {
		g.CancelAction(p)
	}

	mob := g.findMob(sess, input, p.RoomID)
	if mob == nil {
		return
	}

	if mob.HP <= 0 {
		sess.WriteLine("That is already dead.")
		return
	}

	if mob.Protected {
		sess.WriteLine(fmt.Sprintf("You can't attack %s!", mobDisplayName(mob, true)))
		return
	}

	if mob.AssassinLevel > 0 && p.Level(player.Assassin) < mob.AssassinLevel {
		sess.WriteLine(fmt.Sprintf("You need Assassin level %d to attack %s.", mob.AssassinLevel, mobDisplayName(mob, true)))
		return
	}

	if combat.IsMobInCombat(mob.InstanceID) {
		sess.WriteLine(fmt.Sprintf("%s is already engaged in combat!", mobDisplayName(mob, false)))
		return
	}

	if itemID, ok := p.Equipment[object.SlotMainHand]; ok {
		if def, err := g.ItemStore.Load(itemID); err == nil && def.WeaponType == object.WeaponRanged {
			if _, hasAmmo := p.Equipment[object.SlotAmmo]; !hasAmmo || p.AmmoQty <= 0 {
				sess.WriteLine("You don't have any ammo equipped.")
				return
			}
		}
	}

	g.startCombat(sess, p, mob)
}

func (g *Game) findMob(sess *net.Session, input string, roomID int) *world.MobInstance {
	lower := strings.ToLower(input)
	mobs := g.MobStore.MobsInRoom(roomID)

	idx := -1
	name := lower
	if dotPos := strings.Index(lower, "."); dotPos > 0 {
		if n, err := strconv.Atoi(lower[:dotPos]); err == nil && n > 0 {
			idx = n
			name = lower[dotPos+1:]
		}
	}

	var exact []*world.MobInstance
	var prefix []*world.MobInstance
	for _, m := range mobs {
		q := m.MatchQuality(name)
		if q == world.MatchExact {
			exact = append(exact, m)
		} else if q == world.MatchPrefix {
			prefix = append(prefix, m)
		}
	}

	candidates := exact
	if len(candidates) == 0 {
		candidates = prefix
	}

	if len(candidates) == 0 {
		sess.WriteLine(fmt.Sprintf("There's no '%s' here.", input))
		return nil
	}

	sort.Slice(candidates, func(i, j int) bool {
		return candidates[i].InstanceID < candidates[j].InstanceID
	})

	if idx > 0 {
		if idx-1 < len(candidates) {
			return candidates[idx-1]
		}
		return nil
	}

	if len(candidates) == 1 {
		return candidates[0]
	}

	seen := make(map[string]bool)
	for _, m := range candidates {
		seen[mobDisplayName(m, false)] = true
	}
	if len(seen) > 1 {
		sess.WriteLine("Which one?")
		return nil
	}
	return candidates[0]
}

func (g *Game) startCombat(sess *net.Session, p *player.Player, mob *world.MobInstance) {
	g.cancelRest(p.Name)
	g.CancelBackgroundAction(p)

	combat.EnterCombat(p.Name, mob.InstanceID)

	autocastActive := p.AutocastMod != ""
	playerSpeed := g.playerWeaponSpeed(p)
	if autocastActive {
		playerSpeed = 5.0
	}

	if !autocastActive {
		attBonus, strBonus, defBonus := combat.AttackStyleBonus(string(p.AttackStyle))
		var styleParts []string
		if attBonus > 0 {
			styleParts = append(styleParts, fmt.Sprintf("+%d atk", attBonus))
		}
		if strBonus > 0 {
			styleParts = append(styleParts, fmt.Sprintf("+%d str", strBonus))
		}
		if defBonus > 0 {
			styleParts = append(styleParts, fmt.Sprintf("+%d def", defBonus))
		}
		styleStr := ""
		if len(styleParts) > 0 {
			styleStr = " Style: " + string(p.AttackStyle) + " (" + strings.Join(styleParts, ", ") + ")"
		}
		sess.WriteLine(fmt.Sprintf("\nYou attack %s!%s", g.colorize(sess, "mob_name", mobDisplayName(mob, true)), styleStr))
	} else {
		mod := GetMod(p.AutocastMod)
		modName := p.AutocastMod
		if mod != nil {
			modName = mod.Name
		}
		sess.WriteLine(fmt.Sprintf("\nYou attack %s with %s!",
			g.colorize(sess, "mob_name", mobDisplayName(mob, true)),
			g.colorize(sess, "science_mod", modName)))
	}
	p.ActionState = &ActionState{Type: ActionCombating, TargetName: mob.Name}

	g.Ticks.Subscribe(engine.ToTicks(playerSpeed), func() bool {
		cs := combat.GetCombat(p.Name)
		if cs == nil || !cs.Active {
			return false
		}
		currentMob := g.MobStore.GetInstance(cs.MobID)
		if currentMob == nil || currentMob.HP <= 0 {
			g.endCombat(sess, p, currentMob)
			return false
		}
		if p.AutocastMod != "" {
			mod := GetMod(p.AutocastMod)
			if mod != nil {
				if !g.scienceAttack(sess, p, currentMob, mod) {
					p.AutocastMod = ""
					sess.WriteLine("You've run out of junk. Switching to melee.")
					g.playerAttack(sess, p, currentMob)
				}
			} else {
				p.AutocastMod = ""
				g.playerAttack(sess, p, currentMob)
			}
		} else {
			g.playerAttack(sess, p, currentMob)
		}
		if currentMob.HP <= 0 {
			g.endCombat(sess, p, currentMob)
			return false
		}
		return true
	})

	g.Ticks.Subscribe(engine.ToTicks(mob.Speed), func() bool {
		cs := combat.GetCombat(p.Name)
		if cs == nil || !cs.Active {
			return false
		}
		currentMob := g.MobStore.GetInstance(cs.MobID)
		if currentMob == nil || currentMob.HP <= 0 {
			return false
		}
		g.mobAttack(sess, p, currentMob)
		if p.HP <= 0 {
			g.endCombat(sess, p, currentMob)
			return false
		}
		return true
	})
}

func (g *Game) playerAttack(sess *net.Session, p *player.Player, mob *world.MobInstance) {
	if g.processConsumeQueue(p, sess) {
		p.ActionState = &ActionState{Type: ActionEating, TargetName: "food"}
		return
	}

	attackType := "crush"
	var weaponType object.WeaponType
	if itemID, ok := p.Equipment[object.SlotMainHand]; ok {
		if def, err := g.ItemStore.Load(itemID); err == nil {
			if def.AttackType != "" {
				attackType = def.AttackType
			} else if def.WeaponType == object.WeaponRanged {
				attackType = "ranged"
			} else if def.WeaponType == object.WeaponScience {
				attackType = "science"
			}
			weaponType = def.WeaponType
		}
	}

	totals := g.playerEquipBonuses(p)
	isRanged := weaponType == object.WeaponRanged

	var attRoll, defRoll, maxHit int

	if isRanged {
		rangedBonus, _ := combat.RangedStyleBonus(string(p.AttackStyle))
		equipAttack := totals.RangedAttack
		effectiveRanged := p.Level(player.Ranged) + g.techLevelBonus(p, "ranged")
		attRoll = combat.AttackRoll(effectiveRanged, rangedBonus, equipAttack)

		mobDefBonus := combat.SelectDefenseBonus(attackType,
			mob.StabDefense, mob.SlashDefense, mob.CrushDefense,
			mob.ScienceDefense, mob.RangedDefense)
		defRoll = combat.DefenseRoll(mob.Defense, 0, mobDefBonus)
		maxHit = combat.MaxHit(effectiveRanged, rangedBonus, totals.RangedStrength)
	} else {
		attBonus, strBonus, _ := combat.AttackStyleBonus(string(p.AttackStyle))
		equipAttack := combat.SelectAttackBonus(attackType,
			totals.StabAttack, totals.SlashAttack, totals.CrushAttack,
			totals.ScienceAttack, totals.RangedAttack)
		effectiveAttack := p.Level(player.Attack) + g.techLevelBonus(p, "attack")
		attRoll = combat.AttackRoll(effectiveAttack, attBonus, equipAttack)

		mobDefBonus := combat.SelectDefenseBonus(attackType,
			mob.StabDefense, mob.SlashDefense, mob.CrushDefense,
			mob.ScienceDefense, mob.RangedDefense)
		defRoll = combat.DefenseRoll(mob.Defense, 0, mobDefBonus)
		maxHit = combat.MaxHit(p.Level(player.Strength)+g.techLevelBonus(p, "strength"), strBonus, totals.StrengthBonus)
	}

	if combat.HitCheck(attRoll, defRoll) {
		dmg := combat.RollDamage(maxHit)

		mob.HP -= dmg
		if mob.HP < 0 {
			mob.HP = 0
		}
		if mob.FinishingBlow != "" && mob.HP <= 0 {
			mob.HP = 1
		}
		if mob.HP < mob.MaxHP && mob.HP > 0 {
			mob.StartRegen()
		}

		if mob.FinishingBlow != "" && mob.HP == 1 {
			fbDef, _ := g.ItemStore.Load(mob.FinishingBlow)
			fbName := mob.FinishingBlow
			if fbDef != nil {
				fbName = fbDef.Name
			}
			sess.WriteLine(g.colorize(sess, "warning",
				fmt.Sprintf("  %s resists death! Use %s on it to finish it off.",
					mobDisplayName(mob, false), fbName)))
		}
		gains, leveled := g.awardCombatXP(p, dmg, isRanged)

		if isRanged {
			p.AmmoQty--
			if p.AmmoQty <= 0 {
				delete(p.Equipment, object.SlotAmmo)
				p.AmmoQty = 0
			}
			g.AccountStore.SaveCharacter(p)
		}

		for _, skill := range leveled {
			sess.WriteLine(g.colorize(sess, "level_up", fmt.Sprintf("*** You are now level %d %s! ***", p.Level(skill), skill)))
		}

		mobName := mobDisplayName(mob, true)
		attacker := mob.Name
		if !mob.Unique {
			attacker = "The " + mob.Name
		}
		w := len(fmt.Sprintf("  You hit %s for %d damage.", mobName, dmg))
		if w2 := len(fmt.Sprintf("  %s hits you for %d damage.", attacker, dmg)); w2 > w {
			w = w2
		}
		g.combatPadWidth = w
		prefix := fmt.Sprintf("  You hit %s for %s damage.", g.colorize(sess, "mob_name", mobName), g.colorize(sess, "damage", fmt.Sprint(dmg)))
		hpPart := fmt.Sprintf("[%s/%dhp]", g.colorize(sess, "enemy_hp", fmt.Sprint(mob.HP)), mob.MaxHP)
		line := fmt.Sprintf("%-*s %s", g.combatPadWidth, prefix, hpPart)
		if p.OptionBool("xp_drops") && len(gains) > 0 {
			var parts []string
			for _, gain := range gains {
				parts = append(parts, fmt.Sprintf("+%dxp %s", gain.XP, player.SkillAbbr[player.SkillName(gain.Skill)]))
			}
			line += g.colorize(sess, "xp", " ("+strings.Join(parts, ", ")+")")
		}
		sess.WriteLine(line)

		if isRanged && p.AmmoQty <= 0 {
			sess.WriteLine("You've run out of ammo!")
			combat.LeaveCombat(p.Name)
		}
	} else {
		sess.WriteLine(g.colorize(sess, "miss", fmt.Sprintf("  You miss %s.", mobDisplayName(mob, true))))

		if isRanged {
			p.AmmoQty--
			if p.AmmoQty <= 0 {
				delete(p.Equipment, object.SlotAmmo)
				p.AmmoQty = 0
				g.AccountStore.SaveCharacter(p)
				sess.WriteLine("You've run out of ammo!")
				combat.LeaveCombat(p.Name)
			}
		}
	}
}

func (g *Game) mobAttack(sess *net.Session, p *player.Player, mob *world.MobInstance) {
	cs := combat.GetCombat(p.Name)
	_, _, defStyleBonus := combat.AttackStyleBonus(string(p.AttackStyle))

	mobAttackType := mob.AttackType
	if mobAttackType == "" {
		mobAttackType = "crush"
	}

	attRoll := combat.AttackRoll(mob.Attack, 0, mob.AttackBonus)

	totals := g.playerEquipBonuses(p)
	equipDef := combat.SelectDefenseBonus(mobAttackType,
		totals.StabDefense, totals.SlashDefense, totals.CrushDefense,
		totals.ScienceDefense, totals.RangedDefense)
	defRoll := combat.DefenseRoll(p.Level(player.Defense)+g.techLevelBonus(p, "defense"), defStyleBonus, equipDef)

	if combat.HitCheck(attRoll, defRoll) {
		maxHit := combat.MaxHit(mob.Strength, 0, mob.StrengthBonus)
		dmg := combat.RollDamage(maxHit)
		dmg = g.applyTechProtection(p, mob, dmg)

		if mob.DamageWithout != "" {
			hasProtection := false
			for _, itemID := range p.Equipment {
				if itemID == mob.DamageWithout {
					hasProtection = true
					break
				}
			}
			if !hasProtection {
				dmg = dmg * 3 / 2
				if dmg < 1 {
					dmg = 1
				}
				if cs != nil && !cs.DamageWarningShown {
					cs.DamageWarningShown = true
					fbDef, _ := g.ItemStore.Load(mob.DamageWithout)
					fbName := mob.DamageWithout
					if fbDef != nil {
						fbName = fbDef.Name
					}
					attacker := mob.Name
					if !mob.Unique {
						attacker = "The " + mob.Name
					}
					sess.WriteLine(g.colorize(sess, "warning",
						fmt.Sprintf("  %s's attack is extra effective! Equip %s for protection.",
							attacker, fbName)))
				}
			}
		}

		p.HP -= dmg
		if p.HP < 0 {
			p.HP = 0
		}
		p.StartRegen()
		g.AccountStore.SaveCharacter(p)

		attacker := mob.Name
		if !mob.Unique {
			attacker = "The " + mob.Name
		}
		mobName := mobDisplayName(mob, true)
		w := len(fmt.Sprintf("  %s hits you for %d damage.", attacker, dmg))
		if w2 := len(fmt.Sprintf("  You hit %s for %d damage.", mobName, dmg)); w2 > w {
			w = w2
		}
		g.combatPadWidth = w
		prefix := fmt.Sprintf("  %s hits you for %s damage.", g.colorize(sess, "mob_name", attacker), g.colorize(sess, "damage", fmt.Sprint(dmg)))
		hpPart := fmt.Sprintf("[%s/%dhp]", g.colorize(sess, "character_hp", fmt.Sprint(p.HP)), p.MaxHP())
		sess.WriteLine(fmt.Sprintf("%-*s %s", g.combatPadWidth, prefix, hpPart))

		if p.MoveTicks > 0 {
			p.ClearMoveState()
			p.ActionState = &ActionState{Type: ActionCombating, TargetName: mob.Name}
			sess.WriteLine("Can't escape!")
		}
	} else {
		attacker := mob.Name
		if !mob.Unique {
			attacker = "The " + mob.Name
		}
		sess.WriteLine(g.colorize(sess, "miss", fmt.Sprintf("  %s misses you.", attacker)))
	}
}

func (g *Game) endCombat(sess *net.Session, p *player.Player, mob *world.MobInstance) {
	g.combatPadWidth = 0
	combat.LeaveCombat(p.Name)
	p.ActionState = nil

	if p.HP <= 0 {
		if p.HasActiveTech("retribution") {
			retDef := GetTechDef("retribution")
			if retDef != nil && mob != nil && mob.HP > 0 {
				retDmg := int(float64(p.MaxHP()) * retDef.Effects.RetributionPct)
				if retDmg > 0 {
					mob.HP -= retDmg
					if mob.HP < 0 {
						mob.HP = 0
					}
					sess.WriteLine(fmt.Sprintf("\nDead Man's Switch activates! %s takes %d damage!",
						mobDisplayName(mob, true), retDmg))
				}
			}
		}
		p.DeactivateAllTechs()
		sess.WriteLine(g.colorize(sess, "death", "\nOh dear, you are dead!"))
		p.ClearMoveState()
		g.dropItemsOnDeath(p)
		p.HP = p.MaxHP()
		p.RoomID = 1
		g.AccountStore.SaveCharacter(p)
		if g.Hub != nil {
			g.Hub.EnterRoom(sess, p.RoomID)
		}
		g.doLook(sess)
		g.writePrompt(sess)
		return
	}

	if mob != nil && mob.HP <= 0 {
		sess.WriteLine(g.colorize(sess, "victory", fmt.Sprintf("\nYou have defeated %s!", mobDisplayName(mob, true))))

		g.onAssassinKill(sess, p, mob)

		if g.Hub != nil {
			for _, other := range g.Hub.PlayersInRoom(p.RoomID) {
				if other != sess && other.Player != nil {
					op := other.Player.(*player.Player)
					mobLvl := mobCombatLevel(mob)
					levelStr := g.levelColorize(other, op.CombatLevel(), mobLvl, fmt.Sprintf("(level %d)", mobLvl))
					other.WriteLine(g.colorize(other, "broadcast", fmt.Sprintf("\n%s has slain %s %s!", p.Name, mobDisplayName(mob, false), levelStr)))
				}
			}
		}

		if mob.Drops.Remains != "" {
			g.World.AddReservedGroundItem(p.RoomID, mob.Drops.Remains, 1, p.Name)
			def, _ := g.ItemStore.Load(mob.Drops.Remains)
			name := mob.Drops.Remains
			if def != nil {
				name = def.Name
			}
			dropper := mob.Name
			if !mob.Unique {
				dropper = "The " + mob.Name
			}
			coloredName := g.itemColorize(sess, def, name)
			sess.WriteLine(fmt.Sprintf("  %s %s", g.colorize(sess, "drop_message", dropper+" drops:"), coloredName))
		}

		if len(mob.Drops.Loot) > 0 {
			entry := g.BehaviorStore.ResolveDrop(mob.Drops.Loot)
			if entry != nil && entry.ItemID != "" {
				qty := entry.Quantity
				if qty <= 0 {
					qty = 1
				}
				g.World.AddReservedGroundItem(p.RoomID, entry.ItemID, qty, p.Name)
				def, _ := g.ItemStore.Load(entry.ItemID)
				name := entry.ItemID
				if def != nil {
					name = def.Name
				}
				dropper := mob.Name
				if !mob.Unique {
					dropper = "The " + mob.Name
				}
				coloredName := g.itemColorize(sess, def, name)
				if qty > 1 {
					sess.WriteLine(fmt.Sprintf("  %s %d x %s", g.colorize(sess, "drop_message", dropper+" drops:"), qty, coloredName))
				} else {
					sess.WriteLine(fmt.Sprintf("  %s %s", g.colorize(sess, "drop_message", dropper+" drops:"), coloredName))
				}
			}
		}

		respawnTicks := engine.ToTicks(mob.RespawnTicks)
		if respawnTicks <= 0 {
			respawnTicks = engine.ToTicks(30)
		}
		instanceID := mob.InstanceID
		g.Ticks.Subscribe(respawnTicks, func() bool {
			g.respawnMob(instanceID)
			return false
		})
		g.writePrompt(sess)
	}
}

func (g *Game) awardCombatXP(p *player.Player, dmg int, isRanged bool) ([]xpGain, []player.SkillName) {
	baseXP := dmg * 4
	var gains []xpGain
	var leveledUp []player.SkillName

	if isRanged {
		gains = []xpGain{
			{string(player.Ranged), baseXP * 3 / 4},
			{string(player.Hitpoints), baseXP / 4},
		}
	} else {
		switch p.AttackStyle {
		case player.Accurate:
			gains = []xpGain{{string(player.Attack), baseXP * 3 / 4}, {string(player.Hitpoints), baseXP / 4}}
		case player.Aggressive:
			gains = []xpGain{{string(player.Strength), baseXP * 3 / 4}, {string(player.Hitpoints), baseXP / 4}}
		case player.Defensive:
			gains = []xpGain{{string(player.Defense), baseXP * 3 / 4}, {string(player.Hitpoints), baseXP / 4}}
		case player.Balanced:
			quarter := baseXP / 4
			gains = []xpGain{
				{string(player.Attack), quarter},
				{string(player.Strength), quarter},
				{string(player.Defense), quarter},
				{string(player.Hitpoints), quarter},
			}
		}
	}

	for _, gain := range gains {
		if newLevel := p.AddSkillXP(player.SkillName(gain.Skill), gain.XP); newLevel > 0 {
			leveledUp = append(leveledUp, player.SkillName(gain.Skill))
		}
	}
	g.AccountStore.SaveCharacter(p)
	return gains, leveledUp
}

func (g *Game) dropItemsOnDeath(p *player.Player) {
	roomID := p.RoomID

	if p.Credits > 0 {
		g.World.AddGroundItem(roomID, "credits", p.Credits)
		p.Credits = 0
	}

	var items []deathDrop

	for slot, inv := range p.Inventory {
		if inv == nil || inv.Quantity <= 0 {
			continue
		}
		val := 0
		if def, err := g.ItemStore.Load(inv.ItemID); err == nil {
			val = def.Value * inv.Quantity
		}
		items = append(items, deathDrop{
			itemID:   inv.ItemID,
			quantity: inv.Quantity,
			totalVal: val,
			invSlot:  slot,
		})
	}

	for eqSlot, itemID := range p.Equipment {
		val := 0
		if def, err := g.ItemStore.Load(itemID); err == nil {
			val = def.Value
		}
		items = append(items, deathDrop{
			itemID:    itemID,
			quantity:  1,
			totalVal:  val,
			isEquip:   true,
			equipSlot: eqSlot,
		})
	}

	if len(items) <= 3 {
		return
	}

	sort.Slice(items, func(i, j int) bool {
		return items[i].totalVal > items[j].totalVal
	})

	for i := 3; i < len(items); i++ {
		it := items[i]
		if it.isEquip {
			delete(p.Equipment, it.equipSlot)
		} else {
			p.SetInvSlot(it.invSlot, nil)
		}
		g.World.AddGroundItem(roomID, it.itemID, it.quantity)
	}
}

func (g *Game) stopCombat(playerName string) {
	if cs := combat.GetCombat(playerName); cs != nil {
		combat.LeaveCombat(playerName)
	}
}

func (g *Game) respawnMob(instanceID string) {
	inst := g.MobStore.GetInstance(instanceID)
	if inst == nil {
		return
	}
	homeRoom := inst.HomeRoomID
	inst.RoomID = homeRoom
	inst.HP = inst.MaxHP
	g.MobStore.RollIdleDescription(inst)

	if g.Hub != nil {
		for _, sess := range g.Hub.PlayersInRoom(homeRoom) {
			if p, ok := sess.Player.(*player.Player); ok && p.OptionBool("mob_spawn") {
				mobLvl := mobCombatLevel(inst)
				levelStr := g.levelColorize(sess, p.CombatLevel(), mobLvl, fmt.Sprintf("(level %d)", mobLvl))
				sess.WriteLine(fmt.Sprintf("\n%s %s spawns in the area.", g.colorize(sess, "mob_name", mobDisplayName(inst, false)), levelStr))
			}
		}
	}
}

func (g *Game) playerWeaponSpeed(p *player.Player) float64 {
	if itemID, ok := p.Equipment[object.SlotMainHand]; ok {
		def, err := g.ItemStore.Load(itemID)
		if err == nil && def.Speed > 0 {
			return def.Speed
		}
	}
		return 5.0
}