extends Node

## 스테이지 관리 및 몬스터 스폰 시스템 (StageManager)

signal stage_start_cooldown_started(duration: float)
signal stage_started(stage: int)

@export var monster_scene: PackedScene
@export var spawn_interval: float = 1.0
@export var monsters_per_stage: int = 100 # 빠른 테스트를 위해 기획보다 약간 낮추거나 15~30마리 수준 설정

# Path3D 노드 경로
@export var path_node_path: NodePath = NodePath("../MonsterPath")

var _path_node: Path3D
var _spawn_timer: Timer
var _cooldown_timer: Timer

var _monsters_spawned_this_stage: int = 0
var _is_spawning: bool = false
var _is_waiting_for_next_stage: bool = false

func _ready() -> void:
	# 노드 참조 획득
	if has_node(path_node_path):
		_path_node = get_node(path_node_path) as Path3D
	else:
		push_error("StageManager: Path3D node not found at path: " + str(path_node_path))
		
	# 스폰 타이머 설정
	_spawn_timer = Timer.new()
	_spawn_timer.wait_time = spawn_interval
	_spawn_timer.one_shot = false
	_spawn_timer.timeout.connect(_on_spawn_timer_timeout)
	add_child(_spawn_timer)
	
	# 대기 시간(쿨다운) 타이머 설정
	_cooldown_timer = Timer.new()
	_cooldown_timer.wait_time = 5.0
	_cooldown_timer.one_shot = true
	_cooldown_timer.timeout.connect(_start_stage_spawning)
	add_child(_cooldown_timer)
	
	# GameManager 시그널 구독 (스테이지 변경 및 몬스터 수 체크)
	GameManager.active_monster_count_changed.connect(_on_active_monster_count_changed)
	
	# 3초 뒤에 첫 번째 스테이지 대기 시간 가동
	_start_next_stage_cooldown(3.0)

## 다음 스테이지 준비 대기 시간 시작
func _start_next_stage_cooldown(duration: float) -> void:
	_is_waiting_for_next_stage = true
	_cooldown_timer.wait_time = duration
	_cooldown_timer.start()
	stage_start_cooldown_started.emit(duration)
	print("Stage Manager: Cooldown started for stage ", GameManager.current_stage, " - Duration: ", duration)

## 실제 스테이지 몬스터 스폰 가동
func _start_stage_spawning() -> void:
	if GameManager.is_game_over:
		return
		
	_is_waiting_for_next_stage = false
	_is_spawning = true
	_monsters_spawned_this_stage = 0
	
	stage_started.emit(GameManager.current_stage)
	print("Stage Manager: Stage ", GameManager.current_stage, " Started!")
	
	_spawn_timer.start()

## 타이머 주기마다 몬스터 스폰
func _on_spawn_timer_timeout() -> void:
	if GameManager.is_game_over or not _is_spawning:
		_spawn_timer.stop()
		return
		
	if not _path_node or not monster_scene:
		push_error("StageManager: Path3D node or Monster scene is missing.")
		_spawn_timer.stop()
		return
		
	# 몬스터 생성 및 경로 배치
	var monster_instance: Node = monster_scene.instantiate()
	_path_node.add_child(monster_instance)
	
	# 몬스터 초기화 (HP, 보상 골드 설정)
	var stage: int = GameManager.current_stage
	var monster_hp: float = 100.0 + (stage - 1) * 50.0
	var monster_gold: int = _get_monster_gold_reward(stage)
	
	if monster_instance.has_method("initialize_monster"):
		monster_instance.call("initialize_monster", monster_hp, monster_gold)
	
	GameManager.increment_monster_count()
	
	_monsters_spawned_this_stage += 1
	
	# 정해진 마릿수 다 스폰하면 타이머 중지
	if _monsters_spawned_this_stage >= monsters_per_stage:
		_is_spawning = false
		_spawn_timer.stop()
		print("Stage Manager: All monsters spawned for stage ", GameManager.current_stage)

## 몬스터 잔여 수 변동 시 다음 스테이지 이동 체크
func _on_active_monster_count_changed(count: int) -> void:
	if GameManager.is_game_over:
		return
		
	# 스폰이 끝났고 필드의 몬스터가 0일 때
	if not _is_spawning and count == 0 and _monsters_spawned_this_stage >= monsters_per_stage and not _is_waiting_for_next_stage:
		# 승리 조건 검증 (20스테이지 클리어 시 승리)
		if GameManager.current_stage >= GameManager.MAX_STAGE:
			GameManager.is_game_over = true
			GameManager.game_victory.emit()
			print("VICTORY: All stages cleared!")
		else:
			# 다음 스테이지로 상태 전이
			GameManager.current_stage += 1
			_start_next_stage_cooldown(5.0)

## 스테이지별 몬스터 처치 보상 골드 테이블 (game_design.md 참고)
func _get_monster_gold_reward(stage: int) -> int:
	if stage >= 20: return 100
	elif stage >= 15: return 60 + (stage - 15) * 8
	elif stage >= 10: return 40 + (stage - 10) * 4
	elif stage >= 5: return 25 + (stage - 5) * 3
	elif stage >= 2: return 18 + (stage - 2) * 2
	else: return 15
