extends GutTest

## Unit tests for CardInstance.gd


## Initialization Tests

func test_initialization():
	var card_data = TestCardData.create_forward("test-id", "Test Card", Enums.Element.FIRE, 3, 5000)
	var card = CardInstance.new(card_data, 0)

	assert_eq(card.card_data, card_data)
	assert_eq(card.owner_index, 0)
	assert_eq(card.controller_index, 0)
	assert_eq(card.current_power, 5000)
	assert_eq(card.state, Enums.CardState.ACTIVE)
	assert_eq(card.damage_received, 0)
	assert_eq(card.turns_on_field, 0)
	assert_false(card.attacked_this_turn)


func test_initialization_with_null_data():
	var card = CardInstance.new(null, 0)

	assert_null(card.card_data)
	assert_eq(card.current_power, 0)


func test_unique_instance_ids():
	var card1 = CardInstance.new(TestCardData.create_forward(), 0)
	var card2 = CardInstance.new(TestCardData.create_forward(), 0)
	var card3 = CardInstance.new(TestCardData.create_forward(), 0)

	assert_ne(card1.instance_id, card2.instance_id)
	assert_ne(card2.instance_id, card3.instance_id)
	assert_ne(card1.instance_id, card3.instance_id)


func test_controller_defaults_to_owner():
	var card = CardInstance.new(TestCardData.create_forward(), 1)

	assert_eq(card.owner_index, 1)
	assert_eq(card.controller_index, 1)


## Card Type Checks

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

	assert_true(forward.is_forward())
	assert_false(backup.is_forward())
	assert_false(summon.is_forward())


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

	assert_false(forward.is_backup())
	assert_true(backup.is_backup())
	assert_false(summon.is_backup())


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

	assert_false(forward.is_summon())
	assert_false(backup.is_summon())
	assert_true(summon.is_summon())


func test_type_check_with_null_data():
	var card = CardInstance.new(null, 0)

	assert_false(card.is_forward())
	assert_false(card.is_backup())
	assert_false(card.is_summon())


## State Management

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

	assert_true(card.is_active())
	assert_false(card.is_dull())


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

	card.dull()

	assert_true(card.is_dull())
	assert_false(card.is_active())


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

	card.activate()

	assert_true(card.is_active())
	assert_false(card.is_dull())


## Power Tests

func test_get_power_base():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	assert_eq(card.get_power(), 5000)


func test_get_power_with_positive_modifier():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	card.power_modifiers.append(1000)

	assert_eq(card.get_power(), 6000)


func test_get_power_with_multiple_modifiers():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	card.power_modifiers.append(1000)
	card.power_modifiers.append(2000)
	card.power_modifiers.append(-500)

	assert_eq(card.get_power(), 7500)


func test_get_power_with_negative_modifier():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	card.power_modifiers.append(-2000)

	assert_eq(card.get_power(), 3000)


func test_get_power_floors_at_zero():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	card.power_modifiers.append(-10000)

	assert_eq(card.get_power(), 0)


## Attack Eligibility Tests

func test_can_attack_basic():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 1  # Been on field for a turn

	assert_true(card.can_attack())


func test_cannot_attack_if_dull():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 1
	card.dull()

	assert_false(card.can_attack())


func test_cannot_attack_if_already_attacked():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 1
	card.attacked_this_turn = true

	assert_false(card.can_attack())


func test_cannot_attack_summoning_sickness():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 0  # Just entered field

	assert_false(card.can_attack())


func test_can_attack_with_haste_on_first_turn():
	var card = CardInstance.new(TestCardData.create_haste_forward(), 0)
	card.turns_on_field = 0  # Just entered field

	assert_true(card.has_haste())
	assert_true(card.can_attack())


func test_backup_cannot_attack():
	var card = CardInstance.new(TestCardData.create_backup(), 0)
	card.turns_on_field = 1

	assert_false(card.can_attack())


func test_summon_cannot_attack():
	var card = CardInstance.new(TestCardData.create_summon(), 0)
	card.turns_on_field = 1

	assert_false(card.can_attack())


## Block Eligibility Tests

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

	assert_true(card.can_block())


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

	assert_false(card.can_block())


func test_backup_cannot_block():
	var card = CardInstance.new(TestCardData.create_backup(), 0)

	assert_false(card.can_block())


func test_can_block_even_on_first_turn():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 0  # Just entered field

	# Blocking doesn't have summoning sickness
	assert_true(card.can_block())


## Ability Detection Tests

func test_has_haste():
	var haste_card = CardInstance.new(TestCardData.create_haste_forward(), 0)
	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)

	assert_true(haste_card.has_haste())
	assert_false(normal_card.has_haste())


func test_has_brave():
	var brave_card = CardInstance.new(TestCardData.create_brave_forward(), 0)
	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)

	assert_true(brave_card.has_brave())
	assert_false(normal_card.has_brave())


func test_has_first_strike():
	var first_strike_card = CardInstance.new(TestCardData.create_first_strike_forward(), 0)
	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)

	assert_true(first_strike_card.has_first_strike())
	assert_false(normal_card.has_first_strike())


func test_ability_checks_with_null_data():
	var card = CardInstance.new(null, 0)

	assert_false(card.has_haste())
	assert_false(card.has_brave())
	assert_false(card.has_first_strike())


## Element Tests

func test_get_element():
	var fire_card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE), 0)
	var ice_card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.ICE), 0)

	assert_eq(fire_card.get_element(), Enums.Element.FIRE)
	assert_eq(ice_card.get_element(), Enums.Element.ICE)


func test_get_elements():
	var elements: Array[Enums.Element] = [Enums.Element.FIRE, Enums.Element.ICE]
	var multi_card = CardInstance.new(TestCardData.create_multi_element_forward("id", "Multi", elements), 0)

	var card_elements = multi_card.get_elements()

	assert_eq(card_elements.size(), 2)
	assert_true(Enums.Element.FIRE in card_elements)
	assert_true(Enums.Element.ICE in card_elements)


func test_is_light_or_dark():
	var fire_card = CardInstance.new(TestCardData.create_forward(), 0)
	var light_card = CardInstance.new(TestCardData.create_light_forward(), 0)
	var dark_card = CardInstance.new(TestCardData.create_dark_forward(), 0)

	assert_false(fire_card.is_light_or_dark())
	assert_true(light_card.is_light_or_dark())
	assert_true(dark_card.is_light_or_dark())


## Damage Tests

func test_apply_damage():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	var broken = card.apply_damage(3000)

	assert_false(broken)
	assert_eq(card.damage_received, 3000)


func test_apply_damage_breaks_card():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	var broken = card.apply_damage(5000)  # Damage equals power

	assert_true(broken)


func test_apply_damage_accumulates():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)

	card.apply_damage(3000)
	var broken = card.apply_damage(2000)  # Total 5000 = power

	assert_true(broken)
	assert_eq(card.damage_received, 5000)


func test_apply_damage_to_backup_fails():
	var card = CardInstance.new(TestCardData.create_backup(), 0)

	var broken = card.apply_damage(1000)

	assert_false(broken)  # Backups can't receive combat damage


func test_apply_damage_considers_modifiers():
	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
	card.power_modifiers.append(2000)  # Power is now 7000

	var broken = card.apply_damage(5000)  # 5000 < 7000

	assert_false(broken)


## Lifecycle Tests

func test_entered_field():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.turns_on_field = 5
	card.attacked_this_turn = true
	card.damage_received = 1000

	card.entered_field()

	assert_eq(card.turns_on_field, 0)
	assert_false(card.attacked_this_turn)
	assert_eq(card.damage_received, 0)


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

	card.start_turn()

	assert_eq(card.turns_on_field, 1)


func test_end_turn_cleanup():
	var card = CardInstance.new(TestCardData.create_forward(), 0)
	card.power_modifiers.append(1000)
	card.power_modifiers.append(-500)
	card.damage_received = 2000
	card.attacked_this_turn = true

	card.end_turn_cleanup()

	assert_eq(card.power_modifiers.size(), 0)
	assert_eq(card.damage_received, 0)
	assert_false(card.attacked_this_turn)


## Display Tests

func test_get_display_name():
	var card = CardInstance.new(TestCardData.create_forward("id", "Cloud"), 0)

	assert_eq(card.get_display_name(), "Cloud")


func test_get_display_name_null_data():
	var card = CardInstance.new(null, 0)

	assert_eq(card.get_display_name(), "Unknown Card")


## Dull Ability Tests

func test_can_use_dull_ability():
	var card = CardInstance.new(TestCardData.create_backup(), 0)
	card.turns_on_field = 1

	assert_true(card.can_use_dull_ability())


func test_cannot_use_dull_ability_summoning_sickness():
	var card = CardInstance.new(TestCardData.create_backup(), 0)
	card.turns_on_field = 0

	assert_false(card.can_use_dull_ability())


func test_can_use_dull_ability_with_haste():
	var card = CardInstance.new(TestCardData.create_haste_forward(), 0)
	card.turns_on_field = 0

	assert_true(card.can_use_dull_ability())