main.gd

extends Node

# Preload classes (like Java imports)
const WrongResultGenerator = preload("res://wrong_result_generator.gd")
const QuestionBankClass = preload("res://generators/question_bank.gd")
const QuestionGeneratorClass = preload("res://generators/question_generator.gd")
const WeightedQuestionGeneratorClass = preload("res://generators/weighted_question_generator.gd")

@export var mob_scene: PackedScene
@export var result_view_scene: PackedScene
@export var fire_effect_scene: PackedScene
@export var floating_text_scene: PackedScene

# Game state
var score: int
var health: int
var pets: Array[String] = []  # Collected pets act as extra shields

const MAX_HEALTH: int = 3
const CORRECT_ANSWER_POINTS: int = 10
const SPAWN_MOBS_ON_SCORE_THRESHOLD: int = 300
const MOBS_GROUP: String = "mobs"

# Pet types in order of earning (emoji representations)
const PET_TYPES: Array[String] = ["🐱", "🐶", "🐦", "🐟", "🐢", "🐰", "🦊", "🐻"]

# Generator for wrong answers
var wrong_generator = WrongResultGenerator.new()

# Question generator (adaptive learning - wrong answers appear more often)
var question_generator: QuestionGeneratorClass
var current_question_index: int = -1

# Array to hold all result views (1 correct + multiple wrong)
var wrong_results_views: Array[Node2D] = []

var correct_result_view: Node2D

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	# Initialize question generator with adaptive learning
	var bank = QuestionBankClass.multiplication_table_5()
	question_generator = WeightedQuestionGeneratorClass.new(bank)


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta: float) -> void:
	pass


func game_over() -> void:
	$MobTimer.stop()
	$HUD.show_game_over()
	$DeathSound.play()

func new_game():
	score = 0
	health = MAX_HEALTH
	pets.clear()
	$Player.start($StartPosition.position)
	$StartTimer.start()
	$LevelTimer.start()
	$MobTimer.wait_time = 2
	$HUD.update_score(score)
	$HUD.update_health(health)
	$HUD.update_pets(pets)
	$HUD.show_message("Get Ready")
	$Music.play()	
	show_result()
	
	
func _on_score_timer_timeout() -> void:
	score += 1
	$HUD.update_score(score)

func _on_start_timer_timeout() -> void:
	pass

func show_result() -> void:
	$MobTimer.stop()
	
	_clear_result_views()
	
	# Move player to center of screen for fair positioning
	_move_player_to_center()
	
	# Use the adaptive question generator
	current_question_index = question_generator.select_question()
	var question_text = question_generator.get_question_text(current_question_index)
	var correct_answer = question_generator.get_correct_answer(current_question_index)
	
	# Update the question label display
	$Result/QuestionLabel.text = question_text
	$Result/QuestionLabel.position = Vector2(200, 10)

	var wrong_answers = wrong_generator.generate(correct_answer, 3)

	var all_answers: Array[int] = [correct_answer]
	all_answers.append_array(wrong_answers)
	all_answers.shuffle()
	
	# Generate random positions for answers
	var positions = _generate_random_answer_positions(all_answers.size())
	
	# Spawn a ResultView for each answer at random positions
	for i in range(all_answers.size()):
		var answer = all_answers[i]
		var is_correct = (answer == correct_answer)
		
		var result_view = _spawn_result_view(answer, positions[i])
		if (is_correct):
			correct_result_view = result_view
			correct_result_view.hit.connect(proper_result_hit)
		else:
			wrong_results_views.append(result_view)
			# Bind the result_view to the callback so we know which one was hit
			result_view.hit.connect(incorrect_result_hit.bind(result_view))

	# spawn mobs if appropriate level
	if score >= SPAWN_MOBS_ON_SCORE_THRESHOLD :
		$MobTimer.wait_time = 5
		$MobTimer.start()

## Moves player to the center of the screen
func _move_player_to_center() -> void:
	var screen_size = get_viewport().get_visible_rect().size
	var center = screen_size / 2
	$Player.position = center


## Generates random positions for answers, keeping them spread apart
## and away from the center (where player spawns)
func _generate_random_answer_positions(count: int) -> Array[Vector2]:
	var positions: Array[Vector2] = []
	var screen_size = get_viewport().get_visible_rect().size
	var center = screen_size / 2
	
	# Minimum distance from center (player spawn) and between answers
	var min_distance_from_center = 150.0
	var min_distance_between_answers = 100.0
	
	# Margin from screen edges
	var margin = 50.0
	
	var attempts = 0
	var max_attempts = 100
	
	while positions.size() < count and attempts < max_attempts:
		# Generate random position within screen bounds (with margin)
		var random_pos = Vector2(
			randf_range(margin, screen_size.x - margin),
			randf_range(margin, screen_size.y - margin)
		)
		
		# Check if position is far enough from center
		if random_pos.distance_to(center) < min_distance_from_center:
			attempts += 1
			continue
		
		# Check if position is far enough from other answers
		var valid = true
		for existing_pos in positions:
			if random_pos.distance_to(existing_pos) < min_distance_between_answers:
				valid = false
				break
		
		if valid:
			positions.append(random_pos)
		
		attempts += 1
	
	# Fallback: if we couldn't generate enough positions, use path-based positioning
	if positions.size() < count:
		print("Warning: Using fallback positioning")
		var result_view_location = $ResultPath/PathFollow2D
		for i in range(positions.size(), count):
			result_view_location.progress_ratio = randf()
			positions.append(result_view_location.position)
	
	return positions

func incorrect_result_hit(_wrong_result_view: Node2D) -> void:
	print("❌ WRONG answer hit!")
	
	# Tell generator this question was answered wrong (will appear more often)
	question_generator.on_wrong_answer(current_question_index)
	
	$Player.flash_damage()
	
	# Pets act as shields - lose pet first, then health
	if pets.size() > 0:
		var lost_pet = pets.pop_back()
		_spawn_floating_text("-" + lost_pet, $Player.global_position, Color.ORANGE)
		$HUD.update_pets(pets)
		$HUD.flash_pets_down()
	else:
		health -= 1
		$HUD.update_health(health)
		$HUD.flash_health_down()
		
		if health <= 0:
			game_over()


## Spawns a fire effect at the given position
func _spawn_fire_effect(pos: Vector2) -> void:
	if fire_effect_scene == null:
		print("Warning: fire_effect_scene not assigned!")
		return
	
	var fire = fire_effect_scene.instantiate()
	fire.position = pos
	add_child(fire)

func proper_result_hit() -> void:
	print("✅ CORRECT answer hit!")
	
	# Tell generator this question was answered correctly (will appear less often)
	question_generator.on_correct_answer(current_question_index)
	
	# Clear all mobs with disappear animation
	_clear_all_mobs()
	
	# Spawn floating "+10" at correct answer position
	var center_offset = Vector2(32, 36)
	_spawn_floating_text("+" + str(CORRECT_ANSWER_POINTS), 
		correct_result_view.global_position + center_offset, Color.GOLD)
	
	score += CORRECT_ANSWER_POINTS
	$HUD.update_score(score)
	var tween = $Player.flash_success()
	
	# Every 50 points: earn health or pet
	if score % 50 == 0:
		if health < MAX_HEALTH:
			# Health not full - earn health
			health += 1
			$HUD.update_health(health)
			_spawn_floating_text("+1 ❤️", $Player.global_position, Color.RED)
			var tween_health_up = $HUD.flash_health_up()
			await tween_health_up.finished
		else:
			# Health full - earn a pet!
			var pet_index = pets.size() % PET_TYPES.size()
			var new_pet = PET_TYPES[pet_index]
			pets.append(new_pet)
			$HUD.update_pets(pets)
			_spawn_floating_text("+" + new_pet, $Player.global_position, Color.CYAN)
			var tween_pets = $HUD.flash_pets_up()
			await tween_pets.finished
		show_result()
	else:
		await tween.finished		
		show_result()


## Spawns floating text at the given position
func _spawn_floating_text(text: String, pos: Vector2, color: Color = Color.WHITE) -> void:
	if floating_text_scene == null:
		print("Warning: floating_text_scene not assigned!")
		return
	
	var floating = floating_text_scene.instantiate()
	floating.position = pos
	add_child(floating)
	floating.set_text(text)
	floating.set_color(color)

## Spawns a single ResultView at the given position
func _spawn_result_view(answer: int, pos: Vector2) -> Node2D:
	var result_view = result_view_scene.instantiate()
	result_view.position = pos
	result_view.set_label(answer)
	call_deferred("add_child", result_view)
	return result_view

## Removes all current result views from the scene
func _clear_result_views() -> void:
	# Note: queue_free() automatically cleans up signal connections
	for view in wrong_results_views:
		if is_instance_valid(view):
			view.queue_free()
	wrong_results_views.clear()
	
	if is_instance_valid(correct_result_view):
		correct_result_view.queue_free()
	correct_result_view = null
	
func _on_mob_timer_timeout() -> void:
	$MobTimer.wait_time = 2
	var mob = mob_scene.instantiate()
	# Choose a random location on Path2D.
	var mob_spawn_location = $MobPath/MobSpawnLocation
	mob_spawn_location.progress_ratio = randf()

	# Set the mob's position to the random location.
	mob.position = mob_spawn_location.position

	# Set the mob's direction perpendicular to the path direction.
	var direction = mob_spawn_location.rotation + PI / 2

	# Add some randomness to the direction.
	direction += randf_range(-PI / 4, PI / 4)
	mob.rotation = direction

	# Choose the velocity for the mob.
	var velocity = Vector2(randf_range(150.0, 250.0), 0.0)
	mob.linear_velocity = velocity.rotated(direction)

	# Spawn the mob by adding it to the Main scene.
	add_child(mob)
	mob.add_to_group(MOBS_GROUP)


func _on_level_timer_timeout() -> void:
	pass
	

## Clears all mobs from the scene with disappear animation
func _clear_all_mobs() -> void:
	$MobTimer.stop()
	get_tree().call_group(MOBS_GROUP, "disappear")
	


func hit_by_mob() -> void:
	incorrect_result_hit(null)