class_name BattleDebug
extends Node

#banc d'essai : simule un combat complet IA contre IA.
#le journal n'est PAS ecrit dans la console (trop lent) : il est garde en memoire, puis
#affiche a l'ecran et/ou ecrit dans un fichier a la fin du combat. La console ne recoit qu'un resume.
#ajoute ce node a une scene, regle le format dans l'inspecteur, lance la scene.
#utilise des equipes aleatoires (par defaut) : n'abime pas ton equipe de jeu.

@export var run_on_ready : bool = true
@export_range(1, 3) var player_slots : int = 1 #emplacements du joueur
@export_range(1, 5) var enemy_count : int = 1 #nombre d'adversaires (chacun est un participant)
@export_range(1, 3) var enemy_slots_each : int = 1 #emplacements de chaque adversaire
@export_range(1, 6) var team_size : int = 3
@export_range(1, 100) var level : int = 10
@export var use_game_team : bool = false #true : utilise GameData.player_team (qui sera modifiee !)
@export var max_turns : int = 100 #securite : match nul au-dela (0 = illimite)

@export_group("Sortie")
@export var show_log_on_screen : bool = true
@export var write_log_file : bool = true
const LOG_PATH : String = "user://battle_debug.log"

var _log_layer : CanvasLayer = null

func _ready() -> void:
	if run_on_ready:
		await get_tree().create_timer(0.5).timeout
		run_test()

func run_test() -> void:
	if use_game_team:
		GameData.load_data()
		
	var player_team : PokemonTeam = GameData.player_team if use_game_team else _random_team(maxi(team_size, player_slots))
	
	var setup := BattleSetup.new()
	setup.add(BattleSetup.player_participant(player_team, player_slots, null, BattleAI.new()))
	for i in enemy_count:
		var team : PokemonTeam = _random_team(enemy_slots_each + 1)
		var participant := BattleParticipant.new("Adversaire %d" % (i + 1), team, 1, BattleAI.new(), enemy_slots_each)
		setup.add(participant)
	
	if !setup.is_valid():
		push_error("BattleDebug : combat invalide (une equipe n'a aucun pokemon apte)")
		return
	
	var presenter: BattleLogPresenter = BattleLogPresenter.new()
	var battle := Battle.new(setup, presenter)
	battle.max_turns = max_turns
	var outcome : Battle.Outcome = await battle.run()
	
	var header : String = "===== Combat : %d contre %d =====" % [player_slots, enemy_count * enemy_slots_each]
	var summary : String = "Résultat : %s après %d tours (%d lignes de journal)" % [Battle.Outcome.keys()[outcome], battle.turn, presenter.lines.size()]
	var text : String = header + "\n" + "\n".join(presenter.lines) + "\n===== " + summary + " ====="
	
	print("[BattleDebug] " + summary) #une seule ligne dans la console
	if write_log_file: _write_log(text)
	if show_log_on_screen: _show_log(text, summary)

func _random_team(size : int) -> PokemonTeam:
	var team := PokemonTeam.new()
	var ids : Array = Pokedex.all_ids()
	if ids.is_empty():
		push_error("BattleDebug : le Pokedex ne contient aucun pokemon")
		return team
	for i in size:
		var species : PokemonData = Pokedex.get_pokemon(ids.pick_random())
		if species: team.add_pokemon(PokemonInstance.create(species, level))
	return team

#---------- sortie ----------

func _write_log(text : String) -> void:
	var file := FileAccess.open(LOG_PATH, FileAccess.WRITE)
	if file == null:
		push_warning("BattleDebug : impossible d'ecrire le journal (%s)" % LOG_PATH)
		return
	file.store_string(text)
	file.close()
	print("[BattleDebug] Journal ecrit dans : " + ProjectSettings.globalize_path(LOG_PATH))

func _show_log(text : String, summary : String) -> void:
	#panneau plein ecran avec le journal defilant, ferme par un bouton (ou B / Echap)
	if _log_layer != null: _log_layer.queue_free()
	_log_layer = CanvasLayer.new()
	_log_layer.layer = 100
	add_child(_log_layer)
	
	var panel := PanelContainer.new()
	panel.set_anchors_preset(Control.PRESET_FULL_RECT)
	_log_layer.add_child(panel)
	
	var box := VBoxContainer.new()
	panel.add_child(box)
	
	var title := Label.new()
	title.text = summary
	box.add_child(title)
	
	var log_label := RichTextLabel.new()
	log_label.size_flags_vertical = Control.SIZE_EXPAND_FILL
	log_label.selection_enabled = true
	log_label.scroll_active = true
	log_label.text = text
	box.add_child(log_label)
	
	var close := Button.new()
	close.text = "Fermer"
	close.pressed.connect(func() -> void:
		_log_layer.queue_free()
		_log_layer = null)
	box.add_child(close)
	close.grab_focus()