extends GutTest

## Unit tests for Zone.gd

var zone: Zone


func before_each():
	zone = Zone.new(Enums.ZoneType.HAND, 0)


## Initialization Tests

func test_zone_initializes_with_correct_type():
	assert_eq(zone.zone_type, Enums.ZoneType.HAND)
	assert_eq(zone.owner_index, 0)


func test_zone_initializes_empty():
	assert_eq(zone.get_count(), 0)
	assert_true(zone.is_empty())


func test_zone_default_owner_is_negative_one():
	var shared_zone = Zone.new(Enums.ZoneType.STACK)
	assert_eq(shared_zone.owner_index, -1)


## Add Card Tests

func test_add_card_succeeds():
	var card_data = TestCardData.create_forward()
	var card = CardInstance.new(card_data, 0)

	var result = zone.add_card(card)

	assert_true(result)
	assert_eq(zone.get_count(), 1)
	assert_eq(card.zone_type, Enums.ZoneType.HAND)


func test_add_duplicate_card_fails():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)

	var result = zone.add_card(card)

	assert_false(result)
	assert_eq(zone.get_count(), 1)


func test_add_card_at_top_default():
	var card1 = CardInstance.new(TestCardData.create_forward("c1", "Card 1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2", "Card 2"), 0)

	zone.add_card(card1)
	zone.add_card(card2)  # Default is at_top = true

	assert_eq(zone.get_top_card(), card2)
	assert_eq(zone.get_bottom_card(), card1)


func test_add_card_at_bottom():
	var card1 = CardInstance.new(TestCardData.create_forward("c1", "Card 1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2", "Card 2"), 0)

	zone.add_card(card1, true)   # at top
	zone.add_card(card2, false)  # at bottom

	assert_eq(zone.get_top_card(), card1)
	assert_eq(zone.get_bottom_card(), card2)


func test_add_card_updates_card_zone_type():
	var deck_zone = Zone.new(Enums.ZoneType.DECK, 0)
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.zone_type = Enums.ZoneType.HAND

	deck_zone.add_card(card)

	assert_eq(card.zone_type, Enums.ZoneType.DECK)


## Remove Card Tests

func test_remove_card_succeeds():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)

	var result = zone.remove_card(card)

	assert_true(result)
	assert_eq(zone.get_count(), 0)


func test_remove_nonexistent_card_fails():
	var card = CardInstance.new(TestCardData.create_forward(), 0)

	var result = zone.remove_card(card)

	assert_false(result)


## Query Tests

func test_get_cards_returns_copy():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)

	var cards = zone.get_cards()
	cards.clear()  # Modify the returned array

	assert_eq(zone.get_count(), 1)  # Original should be unchanged


func test_has_card():
	var card1 = CardInstance.new(TestCardData.create_forward("c1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2"), 0)
	zone.add_card(card1)

	assert_true(zone.has_card(card1))
	assert_false(zone.has_card(card2))


func test_get_card_at():
	var card1 = CardInstance.new(TestCardData.create_forward("c1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2"), 0)
	zone.add_card(card1)
	zone.add_card(card2)

	assert_eq(zone.get_card_at(0), card1)
	assert_eq(zone.get_card_at(1), card2)
	assert_null(zone.get_card_at(2))
	assert_null(zone.get_card_at(-1))


## Deck Operations Tests

func test_pop_top_card():
	var card1 = CardInstance.new(TestCardData.create_forward("c1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2"), 0)
	zone.add_card(card1)
	zone.add_card(card2)

	var popped = zone.pop_top_card()

	assert_eq(popped, card2)
	assert_eq(zone.get_count(), 1)
	assert_eq(zone.get_top_card(), card1)


func test_pop_top_card_empty_zone():
	var popped = zone.pop_top_card()

	assert_null(popped)


func test_get_top_card_empty_zone():
	assert_null(zone.get_top_card())


func test_get_bottom_card_empty_zone():
	assert_null(zone.get_bottom_card())


func test_shuffle():
	# Add 10 cards
	for i in range(10):
		var card = CardInstance.new(TestCardData.create_forward("c" + str(i), "Card " + str(i)), 0)
		zone.add_card(card)

	var original_order = zone.get_cards().duplicate()
	zone.shuffle()
	var shuffled_order = zone.get_cards()

	# With 10 cards, probability of same order after shuffle is 1/10! = ~0.000028%
	var different = false
	for i in range(10):
		if original_order[i] != shuffled_order[i]:
			different = true
			break
	assert_true(different, "Shuffle should change card order (statistically)")


func test_clear():
	for i in range(5):
		var card = CardInstance.new(TestCardData.create_forward("c" + str(i)), 0)
		zone.add_card(card)

	var removed = zone.clear()

	assert_eq(removed.size(), 5)
	assert_eq(zone.get_count(), 0)
	assert_true(zone.is_empty())


## Type Filtering Tests

func test_get_forwards():
	var forward = CardInstance.new(TestCardData.create_forward(), 0)
	var backup = CardInstance.new(TestCardData.create_backup(), 0)
	var summon = CardInstance.new(TestCardData.create_summon(), 0)
	zone.add_card(forward)
	zone.add_card(backup)
	zone.add_card(summon)

	var forwards = zone.get_forwards()

	assert_eq(forwards.size(), 1)
	assert_eq(forwards[0], forward)


func test_get_backups():
	var forward = CardInstance.new(TestCardData.create_forward(), 0)
	var backup = CardInstance.new(TestCardData.create_backup(), 0)
	zone.add_card(forward)
	zone.add_card(backup)

	var backups = zone.get_backups()

	assert_eq(backups.size(), 1)
	assert_eq(backups[0], backup)


## State Filtering Tests

func test_get_active_cards():
	var card1 = CardInstance.new(TestCardData.create_forward("c1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2"), 0)
	card2.dull()
	zone.add_card(card1)
	zone.add_card(card2)

	var active = zone.get_active_cards()

	assert_eq(active.size(), 1)
	assert_eq(active[0], card1)


func test_get_dull_cards():
	var card1 = CardInstance.new(TestCardData.create_forward("c1"), 0)
	var card2 = CardInstance.new(TestCardData.create_forward("c2"), 0)
	card2.dull()
	zone.add_card(card1)
	zone.add_card(card2)

	var dull = zone.get_dull_cards()

	assert_eq(dull.size(), 1)
	assert_eq(dull[0], card2)


## Search Tests

func test_find_cards_by_name():
	var cloud1 = CardInstance.new(TestCardData.create_forward("c1", "Cloud"), 0)
	var cloud2 = CardInstance.new(TestCardData.create_forward("c2", "Cloud"), 0)
	var tifa = CardInstance.new(TestCardData.create_forward("c3", "Tifa"), 0)
	zone.add_card(cloud1)
	zone.add_card(cloud2)
	zone.add_card(tifa)

	var found = zone.find_cards_by_name("Cloud")

	assert_eq(found.size(), 2)


func test_find_cards_by_element():
	var fire_card = CardInstance.new(TestCardData.create_forward("c1", "Fire Card", Enums.Element.FIRE), 0)
	var ice_card = CardInstance.new(TestCardData.create_forward("c2", "Ice Card", Enums.Element.ICE), 0)
	zone.add_card(fire_card)
	zone.add_card(ice_card)

	var fire_cards = zone.find_cards_by_element(Enums.Element.FIRE)

	assert_eq(fire_cards.size(), 1)
	assert_eq(fire_cards[0], fire_card)


func test_has_card_with_name():
	var card = CardInstance.new(TestCardData.create_forward("c1", "Cloud"), 0)
	zone.add_card(card)

	assert_true(zone.has_card_with_name("Cloud"))
	assert_false(zone.has_card_with_name("Sephiroth"))


func test_has_light_or_dark_with_light():
	var fire_card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(fire_card)
	assert_false(zone.has_light_or_dark())

	var light_card = CardInstance.new(TestCardData.create_light_forward(), 0)
	zone.add_card(light_card)
	assert_true(zone.has_light_or_dark())


func test_has_light_or_dark_with_dark():
	var dark_card = CardInstance.new(TestCardData.create_dark_forward(), 0)
	zone.add_card(dark_card)

	assert_true(zone.has_light_or_dark())


## Callback Tests

func test_on_card_added_callback():
	# Use array to capture value since GDScript lambdas need reference types
	var result = [null]
	zone.on_card_added = func(c): result[0] = c

	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)

	assert_eq(result[0], card)


func test_on_card_removed_callback():
	var result = [null]
	zone.on_card_removed = func(c): result[0] = c

	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)
	zone.remove_card(card)

	assert_eq(result[0], card)


func test_pop_triggers_removed_callback():
	var result = [null]
	zone.on_card_removed = func(c): result[0] = c

	var card = CardInstance.new(TestCardData.create_forward(), 0)
	zone.add_card(card)
	zone.pop_top_card()

	assert_eq(result[0], card)


func test_clear_triggers_removed_callbacks():
	var counter = [0]
	zone.on_card_removed = func(_card): counter[0] += 1

	for i in range(3):
		zone.add_card(CardInstance.new(TestCardData.create_forward("c" + str(i)), 0))

	zone.clear()

	assert_eq(counter[0], 3)