extends RefCounted

## Team manager tests — team assignment, balancing, and queries.
##
## Tests the pure logic of TeamManager without needing a scene tree.
## Uses a mock-like approach: instantiate TeamManager and test its methods
## by directly calling them (requires understanding TeamManager's internal
## data structure for assertions).

# We can't easily instantiate TeamManager without a scene, so we test
# the assignment logic by replicating its algorithm here.

const TEAM_T := 0
const TEAM_CT := 1
const TEAM_NONE := -1

func test_enum_values() -> String:
	var e := ""
	# Verify we have the right enum interpretation
	if TEAM_T != 0:    e += "  T should be 0"
	if TEAM_CT != 1:   e += "  CT should be 1"
	if TEAM_NONE != -1: e += "  NONE should be -1"
	return e

func test_auto_assign_balances_to_t() -> String:
	# auto_assign fills the smaller team.
	# Both teams empty → assigns to T (T count ≤ CT count)
	var t_count := 0
	var ct_count := 0
	var team := TEAM_T if t_count <= ct_count else TEAM_CT
	if team != TEAM_T:
		return "First player should be assigned to T"
	return ""

func test_auto_assign_second_player_to_ct() -> String:
	# After T has 1, CT has 0 → assigns to CT
	var t_count := 1
	var ct_count := 0
	var team := TEAM_T if t_count <= ct_count else TEAM_CT
	if team != TEAM_CT:
		return "Second player should be assigned to CT (1 vs 0)"
	return ""

func test_auto_assign_balances_3_players() -> String:
	# T:1, CT:1 → assign to T (t ≤ ct)
	var t_count := 1
	var ct_count := 1
	var team := TEAM_T if t_count <= ct_count else TEAM_CT
	if team != TEAM_T:
		return "3rd player should be T (T count ≤ CT count)"
	return ""

func test_team_names() -> String:
	var team_names := {
		TEAM_T: "Terrorists",
		TEAM_CT: "Counter-Terrorists",
		TEAM_NONE: "Unassigned",
		-2: "Unassigned",
		99: "Unassigned",
	}
	# Just verify our lookup table is correct
	var e := ""
	if team_names[TEAM_T] != "Terrorists":           e += "  T name wrong"
	if team_names[TEAM_CT] != "Counter-Terrorists":   e += "  CT name wrong"
	if team_names[TEAM_NONE] != "Unassigned":         e += "  NONE name wrong"
	return e

func test_team_membership_counting() -> String:
	# Simulate team assignments like TeamManager.assignments
	var assignments := {
		101: TEAM_T,
		102: TEAM_T,
		103: TEAM_CT,
		104: TEAM_T,
		105: TEAM_CT,
	}

	var t_members: Array[int] = []
	var ct_members: Array[int] = []
	for pid in assignments:
		match assignments[pid]:
			TEAM_T:  t_members.append(pid)
			TEAM_CT: ct_members.append(pid)

	var e := ""
	if t_members.size() != 3:    e += "  T should have 3 members, got %d" % t_members.size()
	if ct_members.size() != 2:   e += "  CT should have 2 members, got %d" % ct_members.size()
	if not (101 in t_members):   e += "  peer 101 should be T"
	if not (105 in ct_members):  e += "  peer 105 should be CT"
	return e

func test_team_count_balance_formula() -> String:
	# Test that auto_assign keeps teams within 1 difference
	var assignments := {}
	var team_counts := { TEAM_T: 0, TEAM_CT: 0 }

	var peers := [201, 202, 203, 204, 205]
	for pid in peers:
		var team := TEAM_T if team_counts[TEAM_T] <= team_counts[TEAM_CT] else TEAM_CT
		assignments[pid] = team
		team_counts[team] += 1

	var e := ""
	var diff = abs(team_counts[TEAM_T] - team_counts[TEAM_CT])
	if diff > 1:
		e += "  Team balance diff should be ≤1, got %d" % diff
	if team_counts[TEAM_T] != 3:   e += "  T should have 3, got %d" % team_counts[TEAM_T]
	if team_counts[TEAM_CT] != 2:  e += "  CT should have 2, got %d" % team_counts[TEAM_CT]
	return e

func test_get_team_returns_none_for_unknown() -> String:
	# get_team() should return NONE for unassigned peers
	var assignments := { 301: TEAM_T }
	var team = assignments.get(999, TEAM_NONE)
	if team != TEAM_NONE:
		return "Unknown peer should return NONE, got %d" % team
	return ""