extends CharacterBody2D


signal health_changed(current_health: int, max_health: int)
signal died


# Collision layers used by this first playable slice.
# Keeping the numbers here makes the scene setup easier to understand:
#   1 -> world
#   2 -> player body
#   3 -> enemy body
#   4 -> player hurtbox
#   5 -> enemy hurtbox
const ENEMY_HURTBOX_MASK: int = 1 << 4


# ============================================================================
# CHARACTER
# ============================================================================

@export_category("Character")

## Resource that identifies the selected band member and contains the stats
## that are allowed to differ between characters.
@export var character_data: CharacterData


# ============================================================================
# MOVEMENT
# ============================================================================

@export_category("Movement")

@export var ground_acceleration: float = 2200.0
@export var ground_friction: float = 2600.0
@export var air_acceleration: float = 1000.0


# ============================================================================
# JUMP
# ============================================================================

@export_category("Jump")

## Allows a jump a few milliseconds after walking off a ledge.
@export var coyote_time: float = 0.12

## Remembers an early jump press just before landing.
@export var jump_buffer_time: float = 0.12

## Releasing jump while rising cuts the jump short.
@export_range(0.1, 1.0) var jump_cut_multiplier: float = 0.45

@export var gravity_multiplier: float = 1.0
@export var fall_gravity_multiplier: float = 1.7
@export var max_fall_speed: float = 1200.0


# ============================================================================
# DAMAGE RECEIVED
# ============================================================================

@export_category("Damage received")

## Short grace period so a contact hitbox cannot drain all health in one frame.
@export var invulnerability_duration: float = 0.65

## Horizontal and vertical impulse applied when the player is hit.
@export var damage_knockback: Vector2 = Vector2(300.0, 260.0)


# ============================================================================
# PUNCH
# ============================================================================

@export_category("Punch")

@export var punch_duration: float = 0.13
@export var punch_cooldown: float = 0.28
@export var punch_hitbox_size: Vector2 = Vector2(55.0, 38.0)
@export var punch_offset: Vector2 = Vector2(48.0, 0.0)


# ============================================================================
# GROUND POUND
# ============================================================================

@export_category("Ground Pound")

## Minimum downward speed when the air attack starts.
@export var ground_pound_start_speed: float = 450.0

## Extra gravity while performing the air attack.
@export var ground_pound_gravity_multiplier: float = 4.5

## Small amount of steering kept during the fall.
@export_range(0.0, 1.0) var ground_pound_horizontal_control: float = 0.25

@export var ground_pound_radius: float = 85.0
@export var ground_pound_offset: Vector2 = Vector2(0.0, 28.0)


# ============================================================================
# DEBUG
# ============================================================================

@export_category("Debug")

## Draws the actual hurtbox and attack areas used by gameplay.
## It is deliberately enabled while the final animations do not exist.
@export var show_debug_hitboxes: bool = true

## Keeps the ground-pound area visible briefly after impact.
@export var debug_impact_duration: float = 0.18


# ============================================================================
# NODES
# ============================================================================

@onready var animated_sprite: AnimatedSprite2D = $AnimatedSprite2D
@onready var hurtbox_collision: CollisionShape2D = $Hurtbox/CollisionShape2D
@onready var punch_hitbox: Area2D = $PunchHitbox
@onready var punch_collision: CollisionShape2D = $PunchHitbox/CollisionShape2D
@onready var ground_pound_hitbox: Area2D = $GroundPoundHitbox
@onready var ground_pound_collision: CollisionShape2D = $GroundPoundHitbox/CollisionShape2D


# ============================================================================
# RUNTIME STATE
# ============================================================================

var current_health: int = 1
var facing_direction: float = 1.0

var coyote_timer: float = 0.0
var jump_buffer_timer: float = 0.0
var invulnerability_timer: float = 0.0

var punch_timer: float = 0.0
var attack_cooldown_timer: float = 0.0

var ground_pound_active: bool = false
var ground_pound_debug_timer: float = 0.0
var is_dead: bool = false

## Prevents one target from receiving damage every physics frame during the
## same punch. A new punch starts with an empty set again.
var punch_hit_targets: Dictionary = {}


func _ready() -> void:
	if character_data == null:
		push_error("Player needs a CharacterData resource.")
		return

	current_health = character_data.max_health
	if character_data.sprite_frames != null:
		animated_sprite.sprite_frames = character_data.sprite_frames

	_setup_attack_hitboxes()
	_update_facing()
	_update_animation()
	health_changed.emit(current_health, character_data.max_health)


func _physics_process(delta: float) -> void:
	if character_data == null or is_dead:
		return

	var was_on_floor: bool = is_on_floor()

	_update_timers(delta)
	_update_jump_windows(delta)
	_handle_attack_input()
	_handle_jump()
	_apply_gravity(delta)
	_handle_horizontal_movement(delta)
	_update_punch_damage()

	move_and_slide()

	# Landing is only reliable after move_and_slide() has resolved collisions.
	if ground_pound_active and not was_on_floor and is_on_floor():
		_ground_pound_impact()

	_update_animation()
	queue_redraw()


# ============================================================================
# MOVEMENT
# ============================================================================

func _handle_horizontal_movement(delta: float) -> void:
	var direction: float = Input.get_axis("move_left", "move_right")

	if direction != 0.0:
		facing_direction = signf(direction)
		_update_facing()

	var target_speed: float = direction * character_data.move_speed

	if ground_pound_active:
		target_speed *= ground_pound_horizontal_control
		velocity.x = move_toward(
			velocity.x,
			target_speed,
			air_acceleration * delta
		)
		return

	if is_on_floor():
		var acceleration: float = ground_acceleration if direction != 0.0 else ground_friction
		velocity.x = move_toward(velocity.x, target_speed, acceleration * delta)
	else:
		velocity.x = move_toward(velocity.x, target_speed, air_acceleration * delta)


func _update_facing() -> void:
	animated_sprite.flip_h = facing_direction < 0.0

	# Only the horizontal offset changes when turning around. The hitbox size
	# stays identical for both directions.
	punch_hitbox.position = Vector2(
		abs(punch_offset.x) * facing_direction,
		punch_offset.y
	)


# ============================================================================
# GRAVITY AND JUMP
# ============================================================================

func _apply_gravity(delta: float) -> void:
	if is_on_floor():
		return

	var gravity: Vector2 = get_gravity()
	var multiplier: float = gravity_multiplier

	if ground_pound_active:
		multiplier = ground_pound_gravity_multiplier
	elif velocity.y > 0.0:
		multiplier = fall_gravity_multiplier

	velocity += gravity * multiplier * delta
	velocity.y = min(velocity.y, max_fall_speed)


func _update_jump_windows(delta: float) -> void:
	if is_on_floor():
		coyote_timer = coyote_time
	else:
		coyote_timer = max(coyote_timer - delta, 0.0)

	if Input.is_action_just_pressed("jump"):
		jump_buffer_timer = jump_buffer_time
	else:
		jump_buffer_timer = max(jump_buffer_timer - delta, 0.0)


func _handle_jump() -> void:
	if (
		jump_buffer_timer > 0.0
		and coyote_timer > 0.0
		and not ground_pound_active
	):
		velocity.y = character_data.jump_velocity
		jump_buffer_timer = 0.0
		coyote_timer = 0.0

	if Input.is_action_just_released("jump") and velocity.y < 0.0:
		velocity.y *= jump_cut_multiplier


# ============================================================================
# ATTACK INPUT
# ============================================================================

func _handle_attack_input() -> void:
	if not Input.is_action_just_pressed("attack"):
		return

	if attack_cooldown_timer > 0.0:
		return

	if is_on_floor():
		_start_punch()
	else:
		_start_ground_pound()


# ============================================================================
# PUNCH
# ============================================================================

func _start_punch() -> void:
	punch_timer = punch_duration
	attack_cooldown_timer = punch_cooldown
	punch_hit_targets.clear()


func _update_punch_damage() -> void:
	if punch_timer <= 0.0:
		return

	for area in punch_hitbox.get_overlapping_areas():
		_damage_target(area, character_data.basic_attack_damage, punch_hit_targets)


# ============================================================================
# GROUND POUND
# ============================================================================

func _start_ground_pound() -> void:
	if ground_pound_active:
		return

	ground_pound_active = true
	attack_cooldown_timer = punch_cooldown

	# If the player is still rising, the attack immediately turns the movement
	# into a fall instead of waiting for the jump apex.
	velocity.y = max(velocity.y, ground_pound_start_speed)


func _ground_pound_impact() -> void:
	ground_pound_active = false
	ground_pound_debug_timer = debug_impact_duration

	var hit_targets: Dictionary = {}

	for area in ground_pound_hitbox.get_overlapping_areas():
		_damage_target(area, character_data.air_attack_damage, hit_targets)


# ============================================================================
# DEALING AND RECEIVING DAMAGE
# ============================================================================

func _damage_target(collider: Node, damage: int, hit_targets: Dictionary) -> void:
	var target: Node = collider

	# Hurtboxes are Area2D children. Damage belongs to the entity that owns the
	# hurtbox, so we ask the parent for take_damage().
	if not target.has_method("take_damage"):
		target = target.get_parent()

	if target == null or not target.has_method("take_damage"):
		return

	var target_id: int = target.get_instance_id()
	if hit_targets.has(target_id):
		return

	hit_targets[target_id] = true
	target.take_damage(damage, global_position)


func take_damage(amount: int, source_position: Vector2) -> void:
	if amount <= 0 or is_dead or invulnerability_timer > 0.0:
		return

	current_health = max(current_health - amount, 0)
	invulnerability_timer = invulnerability_duration

	# Knock the player away from the source. If both centers are aligned, use
	# the opposite of the current facing direction as a deterministic fallback.
	var knockback_direction: float = signf(global_position.x - source_position.x)
	if knockback_direction == 0.0:
		knockback_direction = -facing_direction

	velocity.x = knockback_direction * damage_knockback.x
	velocity.y = -damage_knockback.y

	health_changed.emit(current_health, character_data.max_health)

	if current_health == 0:
		_die()


func _die() -> void:
	is_dead = true
	died.emit()

	# Reloading from a deferred call avoids changing the scene tree while a
	# physics overlap is still being processed.
	call_deferred("_reload_level")


func _reload_level() -> void:
	get_tree().reload_current_scene()


# ============================================================================
# TIMERS AND ANIMATION
# ============================================================================

func _update_timers(delta: float) -> void:
	punch_timer = max(punch_timer - delta, 0.0)
	attack_cooldown_timer = max(attack_cooldown_timer - delta, 0.0)
	ground_pound_debug_timer = max(ground_pound_debug_timer - delta, 0.0)
	invulnerability_timer = max(invulnerability_timer - delta, 0.0)


func _update_animation() -> void:
	# There are only idle and walk animations at the moment. Until proper jump
	# and attack animations arrive, walk is used only for horizontal walking and
	# idle is the safe fallback for every other state.
	if is_on_floor() and abs(velocity.x) > 10.0:
		animated_sprite.play("walk")
	else:
		animated_sprite.play("idle")


# ============================================================================
# HITBOX SETUP
# ============================================================================

func _setup_attack_hitboxes() -> void:
	var punch_shape: RectangleShape2D = RectangleShape2D.new()
	punch_shape.size = punch_hitbox_size
	punch_collision.shape = punch_shape
	punch_hitbox.collision_layer = 0
	punch_hitbox.collision_mask = ENEMY_HURTBOX_MASK
	punch_hitbox.monitoring = true

	var pound_shape: CircleShape2D = CircleShape2D.new()
	pound_shape.radius = ground_pound_radius
	ground_pound_collision.shape = pound_shape
	ground_pound_hitbox.position = ground_pound_offset
	ground_pound_hitbox.collision_layer = 0
	ground_pound_hitbox.collision_mask = ENEMY_HURTBOX_MASK
	ground_pound_hitbox.monitoring = true


# ============================================================================
# DEBUG HITBOX DRAWING
# ============================================================================

func _draw() -> void:
	if not show_debug_hitboxes:
		return

	# Player hurtbox: always visible and deliberately subtle.
	_draw_rectangle_collision(
		hurtbox_collision,
		Color(1.0, 0.08, 0.08, 0.10),
		Color(1.0, 0.08, 0.08, 0.45)
	)

	# Punch: only visible while it can actually deal damage.
	if punch_timer > 0.0:
		_draw_rectangle_collision(
			punch_collision,
			Color(1.0, 0.05, 0.05, 0.25),
			Color(1.0, 0.05, 0.05, 0.95),
			punch_hitbox.position
		)

	# Ground pound: show the real damage radius throughout the fall, then make
	# it stronger for a few frames at the exact impact moment.
	if ground_pound_active or ground_pound_debug_timer > 0.0:
		var fill_alpha: float = 0.14 if ground_pound_active else 0.28
		var outline_alpha: float = 0.60 if ground_pound_active else 0.95
		draw_circle(
			ground_pound_hitbox.position,
			ground_pound_radius,
			Color(1.0, 0.18, 0.05, fill_alpha)
		)
		draw_arc(
			ground_pound_hitbox.position,
			ground_pound_radius,
			0.0,
			TAU,
			48,
			Color(1.0, 0.18, 0.05, outline_alpha),
			2.0
		)


func _draw_rectangle_collision(
	collision: CollisionShape2D,
	fill_color: Color,
	outline_color: Color,
	extra_offset: Vector2 = Vector2.ZERO
) -> void:
	var rectangle: RectangleShape2D = collision.shape as RectangleShape2D
	if rectangle == null:
		return

	var center: Vector2 = collision.position + extra_offset
	var rect: Rect2 = Rect2(center - rectangle.size / 2.0, rectangle.size)
	draw_rect(rect, fill_color, true)
	draw_rect(rect, outline_color, false, 2.0)