class_name DialogueModeController
extends CanvasLayer

signal mode_started(conversation_id: StringName, revision: int)
signal turn_presented(conversation_id: StringName, revision: int)
signal mode_ended(conversation_id: StringName)
signal presentation_failed(reason: StringName)

const TALK_ACTION_ID := &"talk"
const MIN_PANEL_WIDTH := 280.0
const MAX_PANEL_WIDTH := 760.0
const MIN_PANEL_HEIGHT := 210.0
const MAX_PANEL_HEIGHT := 460.0

var _player: Node3D
var _simulation_manager: Node
var _world_view_manager: Node
var _presenter: ConversationPresenter
var _dialogue_runtime: Object

var _conversation_id: StringName
var _presented_turn: ConversationTurn
var _presentation_request := 0
var _presented_option_ids: Array[StringName] = []
var _option_buttons: Array[Button] = []
var _focused_option_index := -1
var _mapping_valid := false
var _mouse_mode_before_dialogue := Input.MOUSE_MODE_CAPTURED
var _owns_visible_mouse := false

var _root_control: Control
var _backdrop: ColorRect
var _panel: PanelContainer
var _speaker_label: Label
var _line_label: Label
var _options_scroll: ScrollContainer
var _options_box: VBoxContainer
var _status_label: Label
var _close_button: Button


func configure(
	player: Node3D,
	simulation_manager: Node,
	world_view_manager: Node,
	presenter: ConversationPresenter = null,
	dialogue_runtime: Object = null
) -> void:
	_player = player
	_simulation_manager = simulation_manager
	_world_view_manager = world_view_manager
	_presenter = presenter
	_dialogue_runtime = dialogue_runtime
	_connect_manager_signals()


func _ready() -> void:
	layer = 20
	_build_balloon()
	_resolve_dependencies()
	_connect_manager_signals()
	set_process_input(false)
	_root_control.visible = false
	get_viewport().size_changed.connect(_layout_balloon)
	_layout_balloon()


func _exit_tree() -> void:
	_presentation_request += 1
	if (
		is_dialogue_active()
		and _simulation_manager != null
		and is_instance_valid(_simulation_manager)
		and _simulation_manager.has_method("end_player_conversation")
	):
		_simulation_manager.call(
			"end_player_conversation", _conversation_id, get_presented_revision()
		)
	_restore_mouse_mode()


func begin_nearest_conversation() -> bool:
	if _player == null or not is_instance_valid(_player):
		return false
	return begin_conversation(_nearest_active_npc_id())


func begin_conversation(npc_id: int) -> bool:
	_resolve_dependencies()
	if (
		npc_id < 0
		or is_dialogue_active()
		or _simulation_manager == null
		or not _simulation_manager.has_method("begin_player_conversation")
		or npc_id != _nearest_active_npc_id()
	):
		return false
	var started_id := StringName(_simulation_manager.call("begin_player_conversation", npc_id))
	return not started_id.is_empty()


func close_conversation() -> bool:
	if not is_dialogue_active():
		return false
	if (
		_simulation_manager == null
		or not is_instance_valid(_simulation_manager)
		or not _simulation_manager.has_method("end_player_conversation")
	):
		_close_local(_conversation_id)
		return false
	var expected_revision := get_presented_revision()
	var ended := bool(
		_simulation_manager.call("end_player_conversation", _conversation_id, expected_revision)
	)
	if not ended:
		_show_status("The conversation changed. Choose again or press close once more.", true)
	return ended


func select_option(option_id: StringName) -> bool:
	if (
		not is_dialogue_active()
		or not _mapping_valid
		or _presented_turn == null
		or not _presented_option_ids.has(option_id)
		or _simulation_manager == null
		or not _simulation_manager.has_method("select_player_conversation_option")
	):
		return false
	var option := _presented_turn.get_option(option_id)
	if option == null or not option.is_enabled():
		return false
	var expected_revision := _presented_turn.get_revision()
	_set_options_enabled(false)
	var result := (
		_simulation_manager.call(
			"select_player_conversation_option", _conversation_id, option_id, expected_revision
		)
		as ConversationSelectionResult
	)
	if result == null:
		_show_status("That response is unavailable.", true)
		_set_options_enabled(true)
		return false
	if result.was_accepted():
		return true
	var current_turn := result.get_turn()
	if current_turn != null and current_turn.is_valid():
		_show_status("The conversation changed; choices were refreshed.", false)
		_queue_turn(current_turn)
	else:
		_show_status("That response is no longer available.", true)
		_set_options_enabled(true)
	return false


func is_dialogue_active() -> bool:
	return not _conversation_id.is_empty()


func get_conversation_id() -> StringName:
	return _conversation_id


func get_presented_revision() -> int:
	return _presented_turn.get_revision() if _presented_turn != null else -1


func get_presented_option_ids() -> Array[StringName]:
	return _presented_option_ids.duplicate()


func get_presented_line() -> String:
	return _line_label.text if _line_label != null else ""


func get_presented_speaker() -> String:
	return _speaker_label.text if _speaker_label != null else ""


func has_valid_option_mapping() -> bool:
	return _mapping_valid


func get_focused_option_id() -> StringName:
	if _focused_option_index < 0 or _focused_option_index >= _presented_option_ids.size():
		return &""
	return _presented_option_ids[_focused_option_index]


func _input(event: InputEvent) -> void:
	if not is_dialogue_active() or event.is_echo():
		return
	if event.is_action_pressed("ui_cancel"):
		close_conversation()
		get_viewport().set_input_as_handled()
		return
	if event.is_action_pressed("ui_down"):
		_move_option_focus(1)
		get_viewport().set_input_as_handled()
		return
	if event.is_action_pressed("ui_up"):
		_move_option_focus(-1)
		get_viewport().set_input_as_handled()
		return
	if event.is_action_pressed("ui_accept") and _focused_option_index >= 0:
		select_option(_presented_option_ids[_focused_option_index])
		get_viewport().set_input_as_handled()


func _resolve_dependencies() -> void:
	if _simulation_manager == null and is_inside_tree():
		_simulation_manager = get_tree().get_first_node_in_group("simulation_manager")
	if _dialogue_runtime == null and is_inside_tree():
		_dialogue_runtime = get_tree().root.get_node_or_null("DialogueManager")
	if _presenter == null:
		_presenter = DialogueManagerConversationPresenter.new(_dialogue_runtime)


func _connect_manager_signals() -> void:
	if _simulation_manager == null or not is_instance_valid(_simulation_manager):
		return
	_connect_once(&"conversation_started", _on_conversation_started)
	_connect_once(&"conversation_turn_changed", _on_conversation_turn_changed)
	_connect_once(&"conversation_ended", _on_conversation_ended)
	_connect_once(&"state_restored", _on_state_restored)


func _connect_once(signal_name: StringName, callback: Callable) -> void:
	if not _simulation_manager.has_signal(signal_name):
		return
	if not _simulation_manager.is_connected(signal_name, callback):
		_simulation_manager.connect(signal_name, callback)


func _on_conversation_started(conversation_id: StringName, turn: ConversationTurn) -> void:
	if turn == null or not turn.is_valid() or turn.get_conversation_id() != conversation_id:
		return
	_conversation_id = conversation_id
	_capture_mouse_mode()
	_root_control.visible = true
	set_process_input(true)
	mode_started.emit(conversation_id, turn.get_revision())
	_queue_turn(turn)


func _on_conversation_turn_changed(conversation_id: StringName, turn: ConversationTurn) -> void:
	if conversation_id != _conversation_id or turn == null or not turn.is_valid():
		return
	_queue_turn(turn)


func _on_conversation_ended(conversation_id: StringName) -> void:
	if conversation_id == _conversation_id:
		_close_local(conversation_id)


func _on_state_restored() -> void:
	if is_dialogue_active():
		_close_local(_conversation_id)


func _queue_turn(turn: ConversationTurn) -> void:
	_presentation_request += 1
	var request := _presentation_request
	_presented_turn = turn.copy()
	_mapping_valid = false
	_presented_option_ids.clear()
	_clear_option_buttons()
	_speaker_label.text = "Conversation"
	_line_label.text = "Listening…"
	_show_status("", false)
	call_deferred("_present_turn", _presented_turn.copy(), request)


func _present_turn(turn: ConversationTurn, request: int) -> void:
	_resolve_dependencies()
	if request != _presentation_request or not is_dialogue_active():
		return
	if _presenter == null or _dialogue_runtime == null:
		_fail_presentation(&"runtime_unavailable")
		return
	var presentation_context := _build_presentation_context(turn)
	var resource: Variant = _presenter.present_turn(turn, presentation_context)
	if not _resource_matches_turn(resource, turn):
		_release_ephemeral_resource(resource, null)
		_fail_presentation(&"resource_mismatch")
		return
	var line: Variant = await _dialogue_runtime.call("get_next_dialogue_line", resource, "start")
	if request != _presentation_request or not is_dialogue_active():
		_release_ephemeral_resource(resource, line)
		return
	if not _line_matches_turn(line, turn):
		_release_ephemeral_resource(resource, line)
		_fail_presentation(&"line_mismatch")
		return
	var mapped := _copy_mapped_responses(line, turn)
	var speaker_text := String(line.get("character"))
	var line_text := String(line.get("text"))
	_release_ephemeral_resource(resource, line)
	if mapped.is_empty() and not turn.is_terminal():
		_fail_presentation(&"option_mapping_invalid")
		return
	_speaker_label.text = speaker_text if not speaker_text.is_empty() else "Villager"
	_line_label.text = line_text
	for copied_response in mapped:
		_add_option_button(
			StringName(copied_response["option_id"]), String(copied_response["text"])
		)
	_mapping_valid = true
	_focus_option(0)
	turn_presented.emit(_conversation_id, turn.get_revision())


func _resource_matches_turn(resource: Variant, turn: ConversationTurn) -> bool:
	return (
		resource is Resource
		and resource.has_meta("conversation_id")
		and resource.has_meta("conversation_revision")
		and String(resource.get_meta("conversation_id")) == String(turn.get_conversation_id())
		and int(resource.get_meta("conversation_revision")) == turn.get_revision()
	)


func _line_matches_turn(line: Variant, turn: ConversationTurn) -> bool:
	return (
		line is Object
		and line.has_method("get_tag_value")
		and line.get("responses") is Array
		and (
			String(line.call("get_tag_value", "conversation_id"))
			== String(turn.get_conversation_id())
		)
		and int(String(line.call("get_tag_value", "revision"))) == turn.get_revision()
	)


func _copy_mapped_responses(line: Variant, turn: ConversationTurn) -> Array[Dictionary]:
	var expected_ids: Array[StringName] = []
	for option in turn.get_options():
		if option.is_enabled():
			expected_ids.append(option.get_option_id())
	var mapped: Array[Dictionary] = []
	var seen: Dictionary = {}
	for response in line.get("responses"):
		if response is not Object or not response.has_method("get_tag_value"):
			return []
		var option_id := StringName(response.call("get_tag_value", "option_id"))
		var option := turn.get_option(option_id)
		if (
			option == null
			or not option.is_enabled()
			or seen.has(option_id)
			or String(response.call("get_tag_value", "enabled")) != "true"
		):
			return []
		seen[option_id] = true
		mapped.append({"option_id": option_id, "text": String(response.get("text"))})
	if mapped.size() != expected_ids.size():
		return []
	for expected_id in expected_ids:
		if not seen.has(expected_id):
			return []
	return mapped


func _build_presentation_context(turn: ConversationTurn) -> Dictionary:
	var entity_names := {}
	for entity in [turn.get_speaker(), turn.get_listener()]:
		var label := _entity_display_name(entity)
		entity_names[String(entity.get_entity_id())] = label
		entity_names[entity.index_key()] = label
	var topic_labels := {}
	for topic_id in turn.get_causal_topic_ids():
		topic_labels[String(topic_id)] = String(topic_id).replace("_", " ")
	return {"entity_names": entity_names, "topic_labels": topic_labels}


func _entity_display_name(entity: WorldEntityRef) -> String:
	if String(entity.get_entity_type()) == "player":
		return "You"
	var entity_id := String(entity.get_entity_id())
	if String(entity.get_entity_type()) == "npc" and entity_id.is_valid_int():
		var npc_name := _npc_name(int(entity_id))
		if not npc_name.is_empty():
			return npc_name
	return entity_id.replace("_", " ").capitalize()


func _npc_name(npc_id: int) -> String:
	if _simulation_manager == null or not ("npcs" in _simulation_manager):
		return ""
	for npc in _simulation_manager.get("npcs"):
		if int(npc.get("id")) == npc_id:
			return String(npc.get("npc_name"))
	return ""


func _nearest_active_npc_id() -> int:
	if (
		_player == null
		or _world_view_manager == null
		or not _world_view_manager.has_method("find_nearest_active_npc_id")
	):
		return -1
	var maximum_distance := float(_player.get("villager_inspection_range"))
	return int(
		_world_view_manager.call(
			"find_nearest_active_npc_id", _player.global_position, maximum_distance
		)
	)


func _fail_presentation(reason: StringName) -> void:
	_mapping_valid = false
	_clear_option_buttons()
	_speaker_label.text = "Conversation unavailable"
	_line_label.text = "The dialogue could not be displayed safely."
	_show_status("Close and try speaking again.", true)
	presentation_failed.emit(reason)


func _close_local(conversation_id: StringName) -> void:
	_presentation_request += 1
	_conversation_id = &""
	_presented_turn = null
	_presented_option_ids.clear()
	_mapping_valid = false
	_focused_option_index = -1
	_clear_option_buttons()
	set_process_input(false)
	if _root_control != null:
		_root_control.visible = false
	_restore_mouse_mode()
	mode_ended.emit(conversation_id)


func _capture_mouse_mode() -> void:
	_mouse_mode_before_dialogue = Input.mouse_mode
	_owns_visible_mouse = Input.mouse_mode != Input.MOUSE_MODE_VISIBLE
	if _owns_visible_mouse:
		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE


func _restore_mouse_mode() -> void:
	if _owns_visible_mouse and Input.mouse_mode == Input.MOUSE_MODE_VISIBLE:
		Input.mouse_mode = _mouse_mode_before_dialogue
	_owns_visible_mouse = false


func _release_ephemeral_resource(resource: Variant, line: Variant) -> void:
	if line is Object:
		var extra_states: Variant = line.get("extra_game_states")
		if extra_states is Array:
			extra_states.clear()
		var responses: Variant = line.get("responses")
		if responses is Array:
			responses.clear()
	if resource is Resource:
		var lines: Variant = resource.get("lines")
		if lines is Dictionary:
			resource.set("lines", {})
		resource.set_script(null)


func _build_balloon() -> void:
	_root_control = Control.new()
	_root_control.name = "DialogueBalloon"
	_root_control.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
	_root_control.mouse_filter = Control.MOUSE_FILTER_STOP
	add_child(_root_control)

	_backdrop = ColorRect.new()
	_backdrop.name = "Backdrop"
	_backdrop.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
	_backdrop.color = Color(0.025, 0.018, 0.012, 0.28)
	_backdrop.mouse_filter = Control.MOUSE_FILTER_STOP
	_root_control.add_child(_backdrop)

	_panel = PanelContainer.new()
	_panel.name = "Panel"
	_panel.mouse_filter = Control.MOUSE_FILTER_STOP
	var panel_style := StyleBoxFlat.new()
	panel_style.bg_color = Color(0.075, 0.055, 0.037, 0.97)
	panel_style.border_color = Color(0.75, 0.52, 0.25, 0.92)
	panel_style.set_border_width_all(2)
	panel_style.set_corner_radius_all(10)
	panel_style.shadow_color = Color(0.0, 0.0, 0.0, 0.45)
	panel_style.shadow_size = 8
	_panel.add_theme_stylebox_override("panel", panel_style)
	_root_control.add_child(_panel)

	var margin := MarginContainer.new()
	margin.add_theme_constant_override("margin_left", 18)
	margin.add_theme_constant_override("margin_top", 14)
	margin.add_theme_constant_override("margin_right", 18)
	margin.add_theme_constant_override("margin_bottom", 12)
	_panel.add_child(margin)

	var content := VBoxContainer.new()
	content.add_theme_constant_override("separation", 8)
	margin.add_child(content)

	_speaker_label = Label.new()
	_speaker_label.name = "Speaker"
	_speaker_label.add_theme_color_override("font_color", Color(0.95, 0.72, 0.38))
	_speaker_label.add_theme_font_size_override("font_size", 18)
	content.add_child(_speaker_label)

	_line_label = Label.new()
	_line_label.name = "Line"
	_line_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
	_line_label.add_theme_color_override("font_color", Color(0.96, 0.91, 0.82))
	_line_label.add_theme_font_size_override("font_size", 16)
	_line_label.size_flags_vertical = Control.SIZE_EXPAND_FILL
	content.add_child(_line_label)

	_options_scroll = ScrollContainer.new()
	_options_scroll.name = "OptionsScroll"
	_options_scroll.custom_minimum_size.y = 76.0
	_options_scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
	_options_scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
	content.add_child(_options_scroll)

	_options_box = VBoxContainer.new()
	_options_box.name = "Options"
	_options_box.size_flags_horizontal = Control.SIZE_EXPAND_FILL
	_options_box.add_theme_constant_override("separation", 5)
	_options_scroll.add_child(_options_box)

	_status_label = Label.new()
	_status_label.name = "Status"
	_status_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
	_status_label.add_theme_font_size_override("font_size", 13)
	content.add_child(_status_label)

	var footer := HBoxContainer.new()
	footer.alignment = BoxContainer.ALIGNMENT_END
	content.add_child(footer)

	var hint := Label.new()
	hint.text = "↑/↓ Navigate  ·  Enter Select  ·  Esc Close"
	hint.add_theme_color_override("font_color", Color(0.68, 0.62, 0.53))
	hint.add_theme_font_size_override("font_size", 12)
	hint.size_flags_horizontal = Control.SIZE_EXPAND_FILL
	footer.add_child(hint)

	_close_button = Button.new()
	_close_button.name = "Close"
	_close_button.text = "Close"
	_close_button.focus_mode = Control.FOCUS_NONE
	_close_button.pressed.connect(close_conversation)
	footer.add_child(_close_button)


func _layout_balloon() -> void:
	if _panel == null:
		return
	var viewport_size := get_viewport().get_visible_rect().size
	var panel_width := minf(MAX_PANEL_WIDTH, maxf(MIN_PANEL_WIDTH, viewport_size.x - 24.0))
	var available_height := maxf(viewport_size.y - 24.0, 120.0)
	var panel_height := minf(
		MAX_PANEL_HEIGHT, maxf(minf(MIN_PANEL_HEIGHT, available_height), viewport_size.y * 0.5)
	)
	panel_height = minf(panel_height, available_height)
	_panel.size = Vector2(panel_width, panel_height)
	_panel.position = Vector2(
		(viewport_size.x - panel_width) * 0.5, maxf(12.0, viewport_size.y - panel_height - 18.0)
	)


func _add_option_button(option_id: StringName, copy: String) -> void:
	var button := Button.new()
	button.text = copy
	button.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
	button.alignment = HORIZONTAL_ALIGNMENT_LEFT
	button.add_theme_font_size_override("font_size", 15)
	button.size_flags_horizontal = Control.SIZE_EXPAND_FILL
	button.set_meta("option_id", option_id)
	button.pressed.connect(select_option.bind(option_id))
	_options_box.add_child(button)
	_option_buttons.append(button)
	_presented_option_ids.append(option_id)


func _clear_option_buttons() -> void:
	for button in _option_buttons:
		if button != null and is_instance_valid(button):
			if button.get_parent() != null:
				button.get_parent().remove_child(button)
			button.queue_free()
	_option_buttons.clear()
	_focused_option_index = -1


func _set_options_enabled(enabled: bool) -> void:
	for button in _option_buttons:
		if button != null and is_instance_valid(button):
			button.disabled = not enabled


func _move_option_focus(direction: int) -> void:
	if _option_buttons.is_empty():
		return
	_focus_option(posmod(_focused_option_index + direction, _option_buttons.size()))


func _focus_option(index: int) -> void:
	if _option_buttons.is_empty():
		_focused_option_index = -1
		return
	_focused_option_index = clampi(index, 0, _option_buttons.size() - 1)
	var button := _option_buttons[_focused_option_index]
	if button != null and is_instance_valid(button):
		button.grab_focus()
		_options_scroll.ensure_control_visible(button)


func _show_status(message: String, is_error: bool) -> void:
	if _status_label == null:
		return
	_status_label.text = message
	_status_label.visible = not message.is_empty()
	_status_label.add_theme_color_override(
		"font_color", Color(0.96, 0.5, 0.36) if is_error else Color(0.82, 0.72, 0.56)
	)