extends CharacterBody3D

signal arrived_at_target(sim_id: int)
signal navigation_failed(sim_id: int)
signal position_changed(sim_id: int, active_position: Vector3)

const DEBUG_LOGS := true

@export var move_speed := 3.0
@export var rotation_speed := 8.0
@export var waypoint_reached_distance := 0.35
@export var stuck_timeout := 1.5

@onready var nav_agent: NavigationAgent3D = $NavigationAgent3D
@onready var body_mesh: MeshInstance3D = $MeshInstance3D
@onready var profession_prop: MeshInstance3D = $ProfessionProp
@onready var profession_label: Label3D = $ProfessionLabel
@onready var carried_food_visual: MeshInstance3D = $CarriedFood
@onready var task_glyph_root: Node3D = $TaskGlyphRoot
@onready var task_glyph: MeshInstance3D = $TaskGlyphRoot/TaskGlyph

var has_reported_arrival := false
var sim_id: int = -1
var npc_name: String = ""
var profession: StringName

var current_path: PackedVector3Array = []
var path_index := 0
var current_target := Vector3.INF
var arrival_distance := 0.6
var stuck_time := 0.0
var path_request_id := 0
var path_pending := false

var is_dead_visual := false
var dead_material := StandardMaterial3D.new()
var debug_overlay_visible := true


func debug_log(message: String) -> void:
	if DEBUG_LOGS:
		print("[NPCVisual] ", name, " | ", message)


func _ready() -> void:
	dead_material.albedo_color = Color(0.25, 0.25, 0.25, 1.0)


func setup_from_sim(npc: SimNPC) -> void:
	sim_id = npc.id
	npc_name = npc.npc_name
	profession = npc.profession
	name = "NPC_%s_%s" % [sim_id, npc_name]
	_apply_profession_presentation()
	set_carried_food_visible(npc.get_inventory_amount(SimulationIds.RESOURCE_FOOD) > 0.0)
	set_task_presentation(npc.current_task, npc.task_state)


func _apply_profession_presentation() -> void:
	var definition := SimulationDefinitions.get_profession(profession)
	if definition == null:
		profession_label.text = npc_name
		profession_prop.visible = false
		return

	var body_material := StandardMaterial3D.new()
	body_material.albedo_color = definition.visual_color
	body_material.roughness = 0.82
	body_mesh.material_override = body_material

	var prop_material := StandardMaterial3D.new()
	prop_material.albedo_color = definition.prop_color
	prop_material.roughness = 0.78
	profession_prop.material_override = prop_material
	profession_prop.mesh = _create_profession_prop_mesh()
	profession_prop.visible = profession_prop.mesh != null
	profession_label.text = "%s\n%s" % [npc_name, definition.display_name]
	profession_label.visible = debug_overlay_visible


func _create_profession_prop_mesh() -> PrimitiveMesh:
	profession_prop.position = Vector3(0.48, 0.85, 0.0)
	profession_prop.rotation_degrees = Vector3.ZERO
	match profession:
		SimulationIds.PROFESSION_FARMER:
			var basket := SphereMesh.new()
			basket.radius = 0.24
			basket.height = 0.34
			return basket
		SimulationIds.PROFESSION_WOODCUTTER:
			var tool := BoxMesh.new()
			tool.size = Vector3(0.12, 0.72, 0.16)
			profession_prop.position = Vector3(0.48, 0.92, 0.0)
			profession_prop.rotation_degrees.z = -18.0
			return tool
		SimulationIds.PROFESSION_GUARD:
			var shield := CylinderMesh.new()
			shield.top_radius = 0.3
			shield.bottom_radius = 0.3
			shield.height = 0.12
			profession_prop.rotation_degrees.x = 90.0
			return shield
		SimulationIds.PROFESSION_SCHOLAR:
			var book := BoxMesh.new()
			book.size = Vector3(0.42, 0.1, 0.3)
			return book
		SimulationIds.PROFESSION_WANDERER:
			var pack := SphereMesh.new()
			pack.radius = 0.28
			pack.height = 0.5
			profession_prop.position = Vector3(-0.42, 0.86, 0.0)
			return pack
	return null


func set_carried_food_visible(is_visible: bool) -> void:
	carried_food_visual.visible = is_visible and not is_dead_visual


func set_task_presentation(action_id: StringName, task_state: StringName) -> void:
	if task_glyph_root == null or task_glyph == null:
		return
	if is_dead_visual or not _should_show_task_glyph(action_id, task_state):
		task_glyph_root.visible = false
		return

	task_glyph.mesh = _create_task_glyph_mesh(action_id)
	task_glyph.material_override = _create_task_glyph_material(action_id)
	task_glyph_root.visible = task_glyph.mesh != null


func set_debug_overlay_visible(is_visible: bool) -> void:
	debug_overlay_visible = is_visible
	if profession_label != null:
		profession_label.visible = is_visible and not is_dead_visual


func set_target_position(pos: Vector3) -> void:
	path_request_id += 1
	var request_id := path_request_id
	current_target = pos
	has_reported_arrival = false
	stuck_time = 0.0
	path_pending = false

	if global_position.distance_to(pos) <= arrival_distance:
		current_path = PackedVector3Array()
		path_index = 0
		debug_log("Already close to target, will report arrival")
		return

	nav_agent.target_position = pos
	path_pending = true

	await get_tree().physics_frame

	if request_id != path_request_id or is_dead_visual:
		return

	current_path = NavigationServer3D.map_get_path(
		get_world_3d().navigation_map, global_position, pos, true
	)

	path_pending = false
	path_index = 0

	if current_path.is_empty():
		debug_log("Path is empty")
		_report_navigation_failure_once()
	else:
		debug_log("New target: %s Path points: %s" % [pos, current_path.size()])


func _physics_process(delta: float) -> void:
	if is_dead_visual:
		velocity = Vector3.ZERO
		move_and_slide()
		return

	if current_target == Vector3.INF:
		velocity = Vector3.ZERO
		move_and_slide()
		return

	if path_pending:
		velocity = Vector3.ZERO
		move_and_slide()
		return

	if global_position.distance_to(current_target) <= arrival_distance:
		_report_arrival_once()
		velocity = Vector3.ZERO
		move_and_slide()
		return

	if current_path.is_empty() or path_index >= current_path.size():
		velocity = Vector3.ZERO
		move_and_slide()
		_report_navigation_failure_once()
		return

	var next_pos := current_path[path_index]
	var to_next := next_pos - global_position

	if to_next.length() <= waypoint_reached_distance:
		path_index += 1
		return

	var direction := to_next.normalized()
	var prev_pos := global_position

	velocity.x = direction.x * move_speed
	velocity.z = direction.z * move_speed
	if not is_on_floor():
		velocity.y -= 30.0 * delta
	else:
		velocity.y = 0.0

	move_and_slide()
	if not global_position.is_equal_approx(prev_pos):
		position_changed.emit(sim_id, global_position)

	var minimum_progress := move_speed * delta * 0.1
	if global_position.distance_squared_to(prev_pos) < minimum_progress * minimum_progress:
		stuck_time += delta
		if stuck_time >= stuck_timeout:
			debug_log("Movement remained blocked")
			_report_navigation_failure_once()
			return
	else:
		stuck_time = 0.0

	var target_angle := atan2(direction.x, direction.z)
	rotation.y = lerp_angle(rotation.y, target_angle, rotation_speed * delta)


func _report_arrival_once() -> void:
	if has_reported_arrival:
		return

	has_reported_arrival = true
	current_path = PackedVector3Array()
	path_index = 0

	debug_log("Arrived at target")
	arrived_at_target.emit(sim_id)


func _report_navigation_failure_once() -> void:
	if has_reported_arrival:
		return

	has_reported_arrival = true
	current_path = PackedVector3Array()
	path_index = 0
	current_target = Vector3.INF
	path_pending = false
	velocity = Vector3.ZERO

	debug_log("Navigation failed")
	navigation_failed.emit(sim_id)


func apply_dead_visual_state() -> void:
	is_dead_visual = true
	carried_food_visual.visible = false
	profession_prop.visible = false
	profession_label.visible = false
	task_glyph_root.visible = false
	path_request_id += 1
	velocity = Vector3.ZERO
	current_path = PackedVector3Array()
	path_index = 0
	current_target = Vector3.INF
	path_pending = false
	has_reported_arrival = true

	scale = Vector3(0.8, 0.25, 1.2)
	rotation_degrees.x = 90.0

	for child in get_children():
		if child is MeshInstance3D:
			child.material_override = dead_material

	collision_layer = 0
	collision_mask = 0
	debug_log("Applied dead visual state")


func _should_show_task_glyph(action_id: StringName, task_state: StringName) -> bool:
	if task_state not in [SimNPC.TASK_STATE_TRAVELING, SimNPC.TASK_STATE_WORKING]:
		return false
	return action_id not in [
		SimulationIds.ACTION_IDLE,
		SimulationIds.ACTION_DEAD,
		SimulationIds.ACTION_WANDER,
	]


func _create_task_glyph_mesh(action_id: StringName) -> PrimitiveMesh:
	task_glyph.rotation_degrees = Vector3.ZERO
	match action_id:
		SimulationIds.ACTION_GATHER_FOOD, SimulationIds.ACTION_EAT, SimulationIds.ACTION_WITHDRAW_FOOD:
			var food := SphereMesh.new()
			food.radius = 0.18
			food.height = 0.26
			return food
		SimulationIds.ACTION_GATHER_WOOD:
			var wood := BoxMesh.new()
			wood.size = Vector3(0.18, 0.42, 0.18)
			task_glyph.rotation_degrees = Vector3(0, 0, -18)
			return wood
		SimulationIds.ACTION_DEPOSIT_FOOD:
			var crate := BoxMesh.new()
			crate.size = Vector3(0.34, 0.22, 0.34)
			return crate
		SimulationIds.ACTION_PATROL:
			var shield := CylinderMesh.new()
			shield.top_radius = 0.2
			shield.bottom_radius = 0.2
			shield.height = 0.1
			task_glyph.rotation_degrees = Vector3(90, 0, 0)
			return shield
		SimulationIds.ACTION_STUDY:
			var book := BoxMesh.new()
			book.size = Vector3(0.36, 0.08, 0.24)
			return book
		SimulationIds.ACTION_REST:
			var rest := SphereMesh.new()
			rest.radius = 0.2
			rest.height = 0.12
			return rest
	return null


func _create_task_glyph_material(action_id: StringName) -> StandardMaterial3D:
	var material := StandardMaterial3D.new()
	material.roughness = 0.65
	material.emission_enabled = true
	material.emission_energy_multiplier = 0.35
	var color := _get_task_glyph_color(action_id)
	material.albedo_color = color
	material.emission = color
	return material


func _get_task_glyph_color(action_id: StringName) -> Color:
	match action_id:
		SimulationIds.ACTION_GATHER_FOOD, SimulationIds.ACTION_EAT, SimulationIds.ACTION_WITHDRAW_FOOD:
			return Color(0.95, 0.42, 0.25, 1.0)
		SimulationIds.ACTION_GATHER_WOOD:
			return Color(0.58, 0.34, 0.16, 1.0)
		SimulationIds.ACTION_DEPOSIT_FOOD:
			return Color(0.95, 0.72, 0.32, 1.0)
		SimulationIds.ACTION_PATROL:
			return Color(0.36, 0.58, 0.95, 1.0)
		SimulationIds.ACTION_STUDY:
			return Color(0.62, 0.46, 0.9, 1.0)
		SimulationIds.ACTION_REST:
			return Color(0.4, 0.78, 0.72, 1.0)
	return Color(0.9, 0.9, 0.85, 1.0)