frame-of-mind/src/logic-scenes/board/card.gd

extends Draggable
class_name Card

var card_id

enum burned {
	NOT,
	SINGED,
	BURNING,
	TORCHED
}

#FIXME remove this legacy stuff without loosing the evil notes ...
var compatible_sticky_notes: Array[StickyNote] = []
@export var evil_sticky_notes: Array[StickyNote] = []
var own_sticky_notes: Array[StickyNote] = []
var current_sticky_note: StickyNote = null
var wiggle_pos: float = 0
var wiggle_intensity: float = 0
var noise: Noise = FastNoiseLite.new()
var wiggle_tween : Tween
var scale_tween : Tween
var brightness_tween : Tween

var transfor_arr: Array[Transform2D] = [
	Transform2D(0.9, Vector2(-125, -83)),
	Transform2D(-0.3, Vector2(-126, -75)),
	Transform2D(-0.3, Vector2(-126, -74)),
	Transform2D(-0.3, Vector2(-126, -73)),
	Transform2D(0.5, Vector2(-126, -77))
]

@export var text: String = "" :
	set(value):
		text = value
		_on_text_updated.call_deferred()

@onready var label: Label = $Label
@onready var background_sprite: AnimatedSprite2D = $AnimatedSprite2D

@export var picked_random: bool = false

@export var wiggle_strength: float = 0.2
@export var wiggle_speed: float = 5
@export_range(1, 2) var scale_bump: float = 1.05
@export_range(1.0, 10.0) var bounce_speed: float = 5
@export_range(1.0, 2.0) var highlight_brightness: float = 1.4
@export var highlighted: bool = false:
	set(highlight):
		if highlight != highlighted:
			highlighted = highlight

			if is_inside_tree() and is_node_ready():
				if scale_tween: scale_tween.kill()
				if wiggle_tween: wiggle_tween.kill()
				if brightness_tween: brightness_tween.kill()
				if highlighted:
					scale_tween = get_tree().create_tween()
					scale_tween.tween_property(self, "scale", Vector2(scale_bump, scale_bump), 0.1)
					wiggle_tween = get_tree().create_tween()
					wiggle_tween.tween_property(self, "wiggle_intensity", 1, 0.2)
					brightness_tween = get_tree().create_tween()
					brightness_tween.set_parallel(true)
					brightness_tween.tween_property(background_sprite, "modulate", Color(highlight_brightness, highlight_brightness, highlight_brightness), 0.15)
					brightness_tween.tween_property(label, "modulate", Color(highlight_brightness, highlight_brightness, highlight_brightness), 0.15)
				else:
					scale_tween = get_tree().create_tween()
					scale_tween.tween_property(self, "scale", Vector2(1, 1), 0.3)
					wiggle_tween = get_tree().create_tween()
					wiggle_tween.tween_property(self, "wiggle_intensity", 0, 0.5)
					brightness_tween = get_tree().create_tween()
					brightness_tween.set_parallel(true)
					brightness_tween.tween_property(background_sprite, "modulate", Color.WHITE, 0.2)
					brightness_tween.tween_property(label, "modulate", Color.WHITE, 0.2)
			else:
				if highlighted:
					scale = Vector2(scale_bump, scale_bump)
					wiggle_intensity = 1
					if background_sprite:
						background_sprite.modulate = Color(highlight_brightness, highlight_brightness, highlight_brightness)
					if label:
						label.modulate = Color(highlight_brightness, highlight_brightness, highlight_brightness)
				else:
					scale = Vector2(1,1)
					wiggle_intensity = 0
					if background_sprite:
						background_sprite.modulate = Color.WHITE
					if label:
						label.modulate = Color.WHITE
					
@export var voice_line: AudioStream = null
@export var is_dragable: bool = false
@export var diameter := 336.0
@export_range(0, 2) var burn_progress: float = 0:
	set(burn):
		if is_node_ready():
			if burn > 0 and background_sprite.material == null:
				if background_sprite != null:
					background_sprite.material = crumble_material.duplicate()
					add_child(card_fire, false, Node.INTERNAL_MODE_FRONT)
					card_fire.material = card_fire.material.duplicate()
			elif burn_progress > 0 and burn <= 0:
				background_sprite.material.set_shader_parameter("fire_progression", 0)
				card_fire.material.set_shader_parameter("fire_progression", 0)
				background_sprite.material = null
				remove_child(card_fire)
		
		burn_progress = burn
		if background_sprite != null and card_fire != null and burn_progress > 0:
			background_sprite.material.set_shader_parameter("fire_progression", burn_progress)
			card_fire.material.set_shader_parameter("fire_progression", burn_progress)
			background_sprite.visible = burn_progress < 2
			card_fire.visible = burn_progress < 2
			label.modulate = Color.WHITE.lerp(Color(0,0,0,0), clampf(burn_progress*3-3, 0, 1))

var burn_tween: Tween
signal has_burned
@export var burn_state: burned = burned.NOT:
	set(burning):
		if burning != burn_state:
			if burn_tween != null:
				burn_tween.kill()
			match burning:
				burned.NOT:
					burn_tween = get_tree().create_tween()
					burn_tween.tween_property(self, "burn_progress", 0, 0.5)
				burned.SINGED:
					burn_tween = get_tree().create_tween()
					burn_tween.set_ease(Tween.EASE_OUT)
					burn_tween.set_trans(Tween.TRANS_SINE)
					burn_tween.tween_property(self, "burn_progress", 0.5, 2)
				burned.BURNING:
					burn_tween = get_tree().create_tween()
					burn_tween.tween_property(self, "burn_progress", 2.0, 2)
					burn_tween.tween_callback(_torch).set_delay(1.0)
				burned.TORCHED:
					print_debug("Card %s has been burned." % HardCards.get_obscure_name(name))
					has_burned.emit()
		burn_state = burning

func _torch():
	burn_state = burned.TORCHED

var crumble_material: ShaderMaterial = preload("res://logic-scenes/card_burner/card_crumble.material")
var card_fire: Sprite2D = preload("res://logic-scenes/card_burner/card_fire.tscn").instantiate()

var sticky_note_position: Vector2 = Vector2(-66, 83)

var mouse_offset: Vector2

func init(card_name: String = "card", own_id:StringName = "-1") -> void:
	if card_name != "c_void":
		text = card_name
	if !card_name.begins_with("c"): 
		push_error("Illegal card.")
	card_id = own_id
	name = card_name
	

func _ready():
	input_event.connect(_on_input_event)
	
	_handle_wiggle(0)	
	_on_text_updated.call_deferred()

func _on_text_updated():
	if is_node_ready():
		var curr_frame := text.hash() % background_sprite.sprite_frames.get_frame_count(background_sprite.animation)
		background_sprite.frame = curr_frame
		
		if text == "":
			if background_sprite.get_child_count() == 0:
				background_sprite.add_child(load("res://logic-scenes/board/void_stuff.tscn").instantiate(), false, Node.INTERNAL_MODE_DISABLED)
		else:
			if background_sprite.get_child_count() > 0:
				background_sprite.get_child(0).queue_free()
		
		label.text = text
		
		wiggle_pos = float(text.hash() % 100)
		
		label.rotation = deg_to_rad(transfor_arr[curr_frame].get_rotation())
		#label.position = transfor_arr[curr_frame].origin
		
		burn_progress = burn_progress
		
		if not Engine.is_editor_hint():
			_handle_wiggle(0)

func _process(delta: float) -> void:
	if highlighted:
		_handle_wiggle(delta)
	
	if get_overlapping_areas().size() > 0 and is_dragable:
		for area in get_overlapping_areas():
			if area is Card:
				if not (area.highlighted or self.highlighted) and area.is_dragable: 
					var diff:Vector2 = position - area.position
					position -= diff.normalized() * ((diff.length()-diameter)/diameter) * bounce_speed * (delta/(1.0/60))
	
	_move_card()

func _handle_wiggle(delta):
	wiggle_pos += delta * wiggle_speed * wiggle_intensity
	
	rotation = noise.get_noise_1d(wiggle_pos)*wiggle_strength


func _input(event: InputEvent) -> void:
	if event is InputEventMouseButton:
		if event.button_index == MOUSE_BUTTON_LEFT and not event.pressed:
			is_dragged = false

func _on_mouse_entered() -> void:
	if not Input.is_action_pressed("mouse_left"):
		# Do nothing if mouse hovers over sticky_note (it has higher priority)
		if has_sticky_note_attached():
			if current_sticky_note and current_sticky_note.highlighted:
				return
		if "handle_hover" in owner:
			owner.handle_hover(self)

func _on_mouse_exited():
	highlighted = false
	if burn_state == burned.SINGED:
		burn_state = burned.NOT

func _on_input_event(_viewport, event, _shape_idx):
	if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
		if "handle_mouse_button" in owner and highlighted:
			mouse_offset = get_viewport().get_mouse_position() - position
			owner.handle_mouse_button(event, self)

func _move_card():
	if is_dragged:
		update_drag_position(get_viewport().get_mouse_position())

func has_sticky_note_attached() -> bool:
	return get_attached_sticky_note() != null

func get_attached_sticky_note() -> StickyNote:
	for child in get_children(false):
		if child is StickyNote:
			return child
	return null
		

func preview_sticky_note(sticky_note: StickyNote):
	if not is_instance_valid(sticky_note):
		return
	sticky_note.reparent(self.get_parent())
	sticky_note.attached_to = self
	# Use a safe transform with validated position
	var target_pos := global_position + sticky_note_position
	if is_finite(target_pos.x) and is_finite(target_pos.y):
		sticky_note.tween_transform_to(Transform2D(0, target_pos))
	else:
		push_warning("Card.preview_sticky_note: Invalid position calculated, skipping tween")

func attach_sticky_note(sticky_note: StickyNote) -> bool:
	if has_sticky_note_attached():
		return false
	
	sticky_note.reparent(self)
	sticky_note.position = sticky_note_position
	sticky_note.on_board = false
	sticky_note.is_dragable = false
	current_sticky_note = sticky_note
	#var former_parent = sticky_note.attached_to
	sticky_note.attached_to = self
	
	if name == "c_hit" and sticky_note.name == "c_effort" and Steamworks.has_initialized:
		Steam.setAchievement("FIGHT_FOR_GOOD")
		Steam.storeStats()
	
	return true

func remove_sticky_note() -> StickyNote:
	var former_child:StickyNote = get_attached_sticky_note()	
	current_sticky_note = null
	former_child.reparent(get_parent())
	former_child.owner = self.owner
	former_child.on_board = true
	former_child.attached_to = owner
	return former_child

func exchange_sticky_note_with(new_note: StickyNote) -> StickyNote:
	var tmp := remove_sticky_note()
	attach_sticky_note(new_note)
	return tmp

# This makes sure this node highlights itself when focus has left the sticky note.
func check_hover():
	# Re-trigger hover handling - owner will decide if this should be highlighted
	_on_mouse_entered()

func reclaim_sticky_note():
	current_sticky_note.on_board = false
	current_sticky_note.tween_transform_to(Transform2D(0, to_global(sticky_note_position)))
	await current_sticky_note.transform_tween_finished
	current_sticky_note.reparent(self)
	current_sticky_note.owner = self.owner


# === DROP TARGET PATTERN IMPLEMENTATION ===

## Temporary storage for exchanged sticky during drop operation
var _last_exchanged_sticky: StickyNote = null

## Checks if this card can accept the given draggable
func can_accept_drop(draggable: Draggable) -> bool:
	return draggable is StickyNote

## Handles dropping a sticky note onto this card
## Returns DropResult indicating success, rejection, or exchange
func handle_drop(draggable: StickyNote) -> int:
	if not can_accept_drop(draggable):
		return Draggable.DropResult.REJECTED
	
	if has_sticky_note_attached():
		# Exchange: remove current, attach new, store old for retrieval
		_last_exchanged_sticky = exchange_sticky_note_with(draggable)
		# Reset z_index for newly attached sticky
		draggable.z_index = 0
		return Draggable.DropResult.EXCHANGED
	else:
		# Simple attach
		if attach_sticky_note(draggable):
			# Reset z_index for newly attached sticky
			draggable.z_index = 0
			return Draggable.DropResult.ACCEPTED
		else:
			# Attach failed (shouldn't happen, but handle it)
			return Draggable.DropResult.REJECTED

## Retrieves the sticky that was exchanged during last drop
## Clears the reference after retrieval
func get_last_exchanged_sticky() -> StickyNote:
	var result = _last_exchanged_sticky
	_last_exchanged_sticky = null
	return result


# === DRAG LIFECYCLE OVERRIDES ===

## Cards always drop back to board dropzone
func find_drop_target() -> Node:
	return owner if owner is CardBoard else get_parent()