# tests/test_gauntlet_registration.gd
# Tests for [Gauntlet] #1 Game Mode Registration
# Validates GAUNTLET enum, string conversion, lobby integration, and arena setup

extends GutTest

func before_all():
	gut.p("=== Gauntlet Registration Tests [Gauntlet #1] ===")

func after_each():
	pass

# =============================================================================
# GameMode Enum Tests
# =============================================================================

# Test 1: GAUNTLET enum value exists and equals 3
func test_gauntlet_enum_exists():
	assert_eq(GameMode.Mode.GAUNTLET, 3, "GAUNTLET should be enum value 3")

# Test 2: All 4 modes are present in enum
func test_all_modes_in_enum():
	assert_eq(GameMode.Mode.FREEMODE, 0, "FREEMODE should be 0")
	assert_eq(GameMode.Mode.STOP_N_GO, 1, "STOP_N_GO should be 1")
	assert_eq(GameMode.Mode.TEKTON_DOORS, 2, "TEKTON_DOORS should be 2")
	assert_eq(GameMode.Mode.GAUNTLET, 3, "GAUNTLET should be 3")

# =============================================================================
# String Conversion Tests
# =============================================================================

# Test 3: from_string recognizes "Candy Cannon Survival"
func test_from_string_candy_cannon():
	var result = GameMode.from_string("Candy Cannon Survival")
	assert_eq(result, GameMode.Mode.GAUNTLET, "from_string should parse 'Candy Cannon Survival' as GAUNTLET")

# Test 4: mode_to_string returns "Candy Cannon Survival" for GAUNTLET
func test_mode_to_string_gauntlet():
	var result = GameMode.mode_to_string(GameMode.Mode.GAUNTLET)
	assert_eq(result, "Candy Cannon Survival", "mode_to_string should return 'Candy Cannon Survival'")

# Test 5: Round-trip conversion is lossless
func test_round_trip_conversion():
	var mode_str = GameMode.mode_to_string(GameMode.Mode.GAUNTLET)
	var mode_enum = GameMode.from_string(mode_str)
	assert_eq(mode_enum, GameMode.Mode.GAUNTLET, "Round-trip should preserve GAUNTLET")

# Test 6: All existing modes still round-trip correctly
func test_existing_modes_round_trip():
	for mode in [GameMode.Mode.FREEMODE, GameMode.Mode.STOP_N_GO, GameMode.Mode.TEKTON_DOORS]:
		var s = GameMode.mode_to_string(mode)
		var back = GameMode.from_string(s)
		assert_eq(back, mode, "Round-trip failed for %s" % s)

# Test 7: Unknown string defaults to FREEMODE
func test_unknown_string_defaults_freemode():
	var result = GameMode.from_string("NonExistentMode")
	assert_eq(result, GameMode.Mode.FREEMODE, "Unknown mode string should default to FREEMODE")

# =============================================================================
# get_all_modes Tests
# =============================================================================

# Test 8: get_all_modes includes "Candy Cannon Survival"
func test_get_all_modes_includes_gauntlet():
	var modes = GameMode.get_all_modes()
	assert_has(modes, "Candy Cannon Survival", "get_all_modes should include 'Candy Cannon Survival'")

# Test 9: get_all_modes returns exactly 4 entries
func test_get_all_modes_count():
	var modes = GameMode.get_all_modes()
	assert_eq(modes.size(), 4, "get_all_modes should return 4 modes")

# Test 10: get_all_modes order is correct
func test_get_all_modes_order():
	var modes = GameMode.get_all_modes()
	assert_eq(modes[0], "Freemode", "First mode should be Freemode")
	assert_eq(modes[1], "Stop n Go", "Second mode should be Stop n Go")
	assert_eq(modes[2], "Tekton Doors", "Third mode should be Tekton Doors")
	assert_eq(modes[3], "Candy Cannon Survival", "Fourth mode should be Candy Cannon Survival")

# =============================================================================
# is_restricted Tests
# =============================================================================

# Test 11: GAUNTLET is a restricted mode
func test_gauntlet_is_restricted():
	var result = GameMode.is_restricted(GameMode.Mode.GAUNTLET)
	assert_true(result, "GAUNTLET should be restricted (dedicated arena)")

# Test 12: FREEMODE is NOT restricted
func test_freemode_not_restricted():
	var result = GameMode.is_restricted(GameMode.Mode.FREEMODE)
	assert_false(result, "FREEMODE should not be restricted")

# Test 13: All restricted modes are confirmed
func test_all_restricted_modes():
	assert_true(GameMode.is_restricted(GameMode.Mode.STOP_N_GO), "STOP_N_GO should be restricted")
	assert_true(GameMode.is_restricted(GameMode.Mode.TEKTON_DOORS), "TEKTON_DOORS should be restricted")
	assert_true(GameMode.is_restricted(GameMode.Mode.GAUNTLET), "GAUNTLET should be restricted")

# =============================================================================
# LobbyManager Integration Tests
# =============================================================================

# Test 14: Lobby available_game_modes includes "Candy Cannon Survival"
func test_lobby_modes_includes_gauntlet():
	var modes = LobbyManager.available_game_modes
	assert_has(modes, "Candy Cannon Survival", "LobbyManager.available_game_modes should include 'Candy Cannon Survival'")

# Test 15: gauntlet_manager.gd script file exists
func test_gauntlet_manager_script_exists():
	var script_exists = ResourceLoader.exists("res://scripts/managers/gauntlet_manager.gd")
	assert_true(script_exists, "gauntlet_manager.gd should exist")

# Test 16: GauntletManager class can be loaded
func test_gauntlet_manager_loads():
	var script = load("res://scripts/managers/gauntlet_manager.gd")
	assert_not_null(script, "gauntlet_manager.gd should load without errors")

# Test 17: GauntletManager has required methods
func test_gauntlet_manager_has_methods():
	var manager = GauntletManager.new()
	assert_true(manager.has_method("_setup_arena"), "GauntletManager should have _setup_arena()")
	assert_true(manager.has_method("_apply_arena_setup"), "GauntletManager should have _apply_arena_setup()")
	assert_true(manager.has_method("start_game_mode"), "GauntletManager should have start_game_mode()")
	assert_true(manager.has_method("initialize"), "GauntletManager should have initialize()")
	manager.free()

# Test 18: GauntletManager arena constants are correct
func test_gauntlet_arena_constants():
	assert_eq(GauntletManager.ARENA_COLUMNS, 20, "Arena should be 20 columns")
	assert_eq(GauntletManager.ARENA_ROWS, 20, "Arena should be 20 rows")
	assert_eq(GauntletManager.NPC_SIZE, 3, "NPC zone should be 3x3")
	assert_eq(GauntletManager.NPC_CENTER, Vector2i(9, 9), "NPC center should be at (9,9)")

# Test 19: NPC zone detection works
func test_npc_zone_detection():
	var manager = GauntletManager.new()
	# Center of NPC zone
	assert_true(manager._is_npc_zone(Vector2i(9, 9)), "Center (9,9) should be NPC zone")
	# Edges of NPC zone
	assert_true(manager._is_npc_zone(Vector2i(8, 8)), "Corner (8,8) should be NPC zone")
	assert_true(manager._is_npc_zone(Vector2i(10, 10)), "Corner (10,10) should be NPC zone")
	# Outside NPC zone
	assert_false(manager._is_npc_zone(Vector2i(7, 9)), "Outside (7,9) should NOT be NPC zone")
	assert_false(manager._is_npc_zone(Vector2i(11, 9)), "Outside (11,9) should NOT be NPC zone")
	assert_false(manager._is_npc_zone(Vector2i(0, 0)), "Corner (0,0) should NOT be NPC zone")
	manager.free()

# Test 20: Phase enum has 3 phases
func test_gauntlet_phases():
	assert_eq(GauntletManager.Phase.OPEN_ARENA, 0, "OPEN_ARENA should be 0")
	assert_eq(GauntletManager.Phase.ROUTE_PRESSURE, 1, "ROUTE_PRESSURE should be 1")
	assert_eq(GauntletManager.Phase.SURVIVAL_ENDGAME, 2, "SURVIVAL_ENDGAME should be 2")

func after_all():
	gut.p("=== Gauntlet Registration Tests Complete ===")