class_name Battle
extends RefCounted

#moteur de combat au tour par tour, sans aucun visuel.
#gere n emplacements par camp (1v1, 2v2, 1 contre plusieurs, plusieurs contre 1).
#
#usage :
#	var battle := Battle.new(setup, mon_presenter)
#	var outcome : Battle.Outcome = await battle.run()
#
#a chaque evenement, la presentation est appelee et le combat attend qu'elle ait fini.

signal event_emitted(event : BattleEvent)

enum Outcome { NONE, PLAYER_WON, PLAYER_LOST, FLED }

const PLAYER_SIDE : int = 0

static var _struggle : MoveData = null

var setup : BattleSetup
var presenter : BattlePresenter
var rng : RandomNumberGenerator = RandomNumberGenerator.new()
var turn : int = 0
var outcome : Outcome = Outcome.NONE
var slots : Array[BattleSlot] = []

func _init(p_setup : BattleSetup, p_presenter : BattlePresenter = null) -> void:
	setup = p_setup
	presenter = p_presenter
	if setup.seed_value != 0: rng.seed = setup.seed_value
	else: rng.randomize()
	_build_slots()

func _build_slots() -> void:
	var per_side_count : Dictionary = {}
	for participant in setup.participants:
		for pokemon in participant.pick_starters():
			var slot := BattleSlot.new()
			slot.id = slots.size()
			slot.side = participant.side
			slot.index = int(per_side_count.get(participant.side, 0))
			per_side_count[participant.side] = slot.index + 1
			slot.participant = participant
			slot.set_pokemon(pokemon)
			slots.append(slot)

#---------- boucle principale ----------

func run() -> Outcome:
	await _emit(BattleEvent.make(BattleEvent.Type.BATTLE_START))
	for slot in slots:
		await _emit(BattleEvent.make(BattleEvent.Type.SENT_OUT, slot))
	
	if _check_end():
		return await _finish()
	
	while outcome == Outcome.NONE:
		turn += 1
		var turn_event := BattleEvent.make(BattleEvent.Type.TURN_START)
		turn_event.amount = turn
		await _emit(turn_event)
		
		var actions : Array[BattleAction] = await _collect_actions()
		_sort_actions(actions)
		for action in actions:
			await _execute(action)
			if _check_end(): break
		if outcome != Outcome.NONE: break
		
		await _replace_fainted()
		if _check_end(): break
	
	return await _finish()

func _finish() -> Outcome:
	var end_event := BattleEvent.make(BattleEvent.Type.BATTLE_END)
	match outcome:
		Outcome.PLAYER_WON: end_event.text = "Victoire !"
		Outcome.PLAYER_LOST: end_event.text = "Défaite..."
		Outcome.FLED: end_event.text = "Vous avez pris la fuite."
	await _emit(end_event)
	return outcome

func _emit(event : BattleEvent) -> void:
	event_emitted.emit(event)
	if presenter != null:
		await presenter.present(event)

func _msg(text : String) -> void:
	var e := BattleEvent.make(BattleEvent.Type.MESSAGE)
	e.text = text
	await _emit(e)

#---------- fin de combat ----------

func _side_alive(side : int) -> bool:
	for participant in setup.participants:
		if participant.side == side and participant.has_able_pokemon(): return true
	return false

func _check_end() -> bool:
	if outcome != Outcome.NONE: return true
	var player_alive : bool = _side_alive(PLAYER_SIDE)
	var enemy_alive : bool = _side_alive(1 - PLAYER_SIDE)
	if player_alive and enemy_alive: return false
	outcome = Outcome.PLAYER_WON if player_alive else Outcome.PLAYER_LOST
	return true

#---------- actions du tour ----------

func _collect_actions() -> Array[BattleAction]:
	var actions : Array[BattleAction] = []
	for slot in slots:
		if !slot.is_active(): continue
		var action : BattleAction = await slot.participant.controller.choose_action(self, slot)
		if action == null: action = BattleAction.use_struggle(slot) #securite : un controleur qui ne decide rien
		actions.append(action)
	return actions

func _sort_actions(actions : Array[BattleAction]) -> void:
	for a in actions:
		match a.type:
			BattleAction.Type.FLEE: a.priority = 8
			BattleAction.Type.SWITCH: a.priority = 7
			BattleAction.Type.ITEM: a.priority = 6
			_: a.priority = a.move.priority if a.move else 0
		a.speed = a.slot.mon.get_stat(PokemonNature.Stat.SPEED)
		a.tiebreak = rng.randf()
	
	actions.sort_custom(func(a : BattleAction, b : BattleAction) -> bool:
		if a.priority != b.priority: return a.priority > b.priority
		if a.speed != b.speed: return a.speed > b.speed
		return a.tiebreak > b.tiebreak)

func _execute(action : BattleAction) -> void:
	if !action.slot.is_active(): return #mis K.O. avant son tour
	match action.type:
		BattleAction.Type.MOVE: await _execute_move(action)
		BattleAction.Type.SWITCH: await _execute_switch(action)
		BattleAction.Type.FLEE: await _execute_flee(action)

func _execute_flee(action : BattleAction) -> void:
	if setup.can_flee and action.slot.side == PLAYER_SIDE:
		outcome = Outcome.FLED
		await _emit(BattleEvent.make(BattleEvent.Type.FLED, action.slot))
	else:
		await _msg("Impossible de fuir !")

func _execute_switch(action : BattleAction) -> void:
	var slot : BattleSlot = action.slot
	if !get_replacement_options(slot).has(action.switch_to): return
	await _emit(BattleEvent.make(BattleEvent.Type.WITHDRAWN, slot))
	slot.set_pokemon(action.switch_to)
	await _emit(BattleEvent.make(BattleEvent.Type.SENT_OUT, slot))

func _execute_move(action : BattleAction) -> void:
	var actor : BattleSlot = action.slot
	var move : MoveData = action.move
	
	if action.move_slot != null:
		if !action.move_slot.use():
			await _msg("%s n'a plus de PP pour cette capacité !" % actor.mon.display_name())
			return
	
	var used := BattleEvent.make(BattleEvent.Type.MOVE_USED, actor)
	used.move = move
	await _emit(used)
	
	var targets : Array[BattleSlot] = TargetResolver.resolve(self, actor, move, action.chosen_target)
	if targets.is_empty():
		await _msg("Mais cela échoue !")
		return
	
	var spread : bool = targets.size() > 1
	var status_message_shown : bool = false
	
	for target in targets:
		if !target.is_active(): continue
		
		if move.power <= 0 or move.category == "status":
			#les effets des capacites de statut ne sont pas encore implementes
			if !status_message_shown:
				status_message_shown = true
				await _msg("Mais cela n'a pas d'effet pour l'instant.")
			continue
		
		if !_hits(move):
			await _emit(BattleEvent.make(BattleEvent.Type.MOVE_MISSED, actor, target))
			continue
		
		var calc : Dictionary = DamageCalculator.calculate(actor.mon, target.mon, move, rng, spread)
		var effectiveness : float = calc["effectiveness"]
		if effectiveness == 0.0:
			await _emit(BattleEvent.make(BattleEvent.Type.NO_EFFECT, actor, target))
			continue
		
		await _apply_damage(actor, target, int(calc["damage"]))
		if calc["critical"]: await _emit(BattleEvent.make(BattleEvent.Type.CRITICAL, actor, target))
		if effectiveness > 1.0: await _emit(BattleEvent.make(BattleEvent.Type.SUPER_EFFECTIVE, actor, target))
		elif effectiveness < 1.0: await _emit(BattleEvent.make(BattleEvent.Type.NOT_VERY_EFFECTIVE, actor, target))
		if target.mon.is_fainted(): await _emit(BattleEvent.make(BattleEvent.Type.FAINTED, target))
		
		if _check_end(): return
	
	#Lutte : contrecoup pour l'utilisateur
	if move.api_name == "struggle" and actor.mon != null and !actor.mon.is_fainted():
		var recoil : int = maxi(1, floori(actor.mon.pokemon.get_max_hp() / 4.0))
		await _apply_damage(actor, actor, recoil)
		if actor.mon.is_fainted(): await _emit(BattleEvent.make(BattleEvent.Type.FAINTED, actor))

func _apply_damage(source : BattleSlot, target : BattleSlot, amount : int) -> void:
	var before : int = target.mon.pokemon.current_hp
	target.mon.pokemon.take_damage(amount)
	var event := BattleEvent.make(BattleEvent.Type.DAMAGE, source, target)
	event.amount = before - target.mon.pokemon.current_hp
	event.hp = target.mon.pokemon.current_hp
	event.max_hp = target.mon.pokemon.get_max_hp()
	await _emit(event)

func _hits(move : MoveData) -> bool:
	#precision 0 = ne rate jamais (valeur PokeAPI "null")
	return move.accuracy <= 0 or rng.randi_range(1, 100) <= move.accuracy

#---------- remplacements ----------

func _replace_fainted() -> void:
	for slot in slots:
		if slot.mon == null or !slot.mon.is_fainted(): continue
		
		var options : Array[PokemonInstance] = get_replacement_options(slot)
		if options.is_empty():
			slot.clear() #plus de remplacant : l'emplacement reste vide
			continue
		
		var chosen : PokemonInstance = await slot.participant.controller.choose_replacement(self, slot)
		if chosen == null or !options.has(chosen): chosen = options[0]
		slot.set_pokemon(chosen)
		await _emit(BattleEvent.make(BattleEvent.Type.SENT_OUT, slot))

#---------- requetes (utilisees par les controleurs et TargetResolver) ----------

func get_slot(id : int) -> BattleSlot:
	return slots[id] if id >= 0 and id < slots.size() else null

func get_active_slots() -> Array[BattleSlot]:
	var result : Array[BattleSlot] = []
	for s in slots:
		if s.is_active(): result.append(s)
	return result

func get_opponents(slot : BattleSlot) -> Array[BattleSlot]:
	var result : Array[BattleSlot] = []
	for s in slots:
		if s.is_active() and s.side != slot.side: result.append(s)
	return result

func get_allies(slot : BattleSlot) -> Array[BattleSlot]:
	var result : Array[BattleSlot] = []
	for s in slots:
		if s.is_active() and s.side == slot.side and s != slot: result.append(s)
	return result

func get_usable_moves(mon : BattleMon) -> Array[MoveSlot]:
	var result : Array[MoveSlot] = []
	for ms in mon.pokemon.active_moves:
		if ms.has_pp(): result.append(ms)
	return result

func get_replacement_options(slot : BattleSlot) -> Array[PokemonInstance]:
	#pokemon aptes de l'equipe du participant qui ne sont pas deja en jeu
	var result : Array[PokemonInstance] = []
	for p in slot.participant.team.members:
		if p.is_fainted() or _is_in_play(p): continue
		result.append(p)
	return result

func _is_in_play(pokemon : PokemonInstance) -> bool:
	for s in slots:
		if s.mon != null and s.mon.pokemon == pokemon: return true
	return false

#---------- Lutte ----------

static func make_struggle() -> MoveData:
	if _struggle == null:
		_struggle = MoveData.new()
		_struggle.api_name = "struggle"
		_struggle.names = {"fr": "Lutte", "en": "Struggle"}
		_struggle.type = "typeless"
		_struggle.category = "physical"
		_struggle.power = 50
		_struggle.accuracy = 0
		_struggle.pp = 1
		_struggle.priority = 0
		_struggle.target = "random-opponent"
	return _struggle