extends PanelContainer

class GoalDefinition extends RefCounted:
	var target_generator_id: StringName
	var goal: GoalData

	func _init(target_id: StringName, goal_data: GoalData) -> void:
		target_generator_id = target_id
		goal = goal_data

const GOAL_DATA_SCRIPT: Script = preload("res://core/goals/goal_data.gd")
const GOAL_REQUIREMENT_SCRIPT: Script = preload("res://core/goals/goal_requirement_data.gd")

class GoalRow extends RefCounted:
	var goal: GoalDefinition
	var status_label: Label
	var requirements_label: Label
	var button: Button

	func _init(goal_definition: GoalDefinition, status: Label, requirements: Label, unlock_button: Button) -> void:
		goal = goal_definition
		status_label = status
		requirements_label = requirements
		button = unlock_button

@onready var _summary_label: Label = $MarginContainer/VBoxContainer/SummaryLabel
@onready var _goals_list: VBoxContainer = $MarginContainer/VBoxContainer/ScrollContainer/GoalsList

var _loaded_goals: Array[GoalDefinition] = []
var _rows_by_goal_id: Dictionary = {}
var _known_generator_ids: Dictionary = {}
var _warned_unknown_target_ids: Dictionary = {}
var _generators_by_id: Dictionary = {}

func _ready() -> void:
	_collect_known_generator_ids()
	_load_goals()
	_build_goal_rows()
	GameState.currency_changed.connect(_on_currency_changed)
	GameState.generator_state_changed.connect(_on_generator_state_changed)
	GameState.goal_completed.connect(_on_goal_completed)
	_refresh_ui()
	_refresh_ui.call_deferred()

func _on_currency_changed(_currency_id: StringName, _new_amount: BigNumber) -> void:
	_refresh_ui()

func _on_goal_completed(goal_id: StringName) -> void:
	_refresh_ui()

func _on_generator_state_changed(generator_id: StringName, _state: Dictionary) -> void:
	var generator_key: String = String(generator_id)
	if not generator_key.is_empty():
		_known_generator_ids[generator_key] = true
		_refresh_generator_lookup(generator_id)
	_refresh_ui()

func _load_goals() -> void:
	_loaded_goals.clear()
	_generators_by_id.clear()

	var scene_root: Node = get_tree().current_scene
	var search_root: Node = scene_root if scene_root != null else self
	var generator_nodes: Array[Node] = search_root.find_children("*", "CurrencyGenerator", true, false)
	
	for generator_node in generator_nodes:
		var generator: CurrencyGenerator = generator_node as CurrencyGenerator
		if generator == null:
			continue

		var generator_id: StringName = generator.get_generator_id()
		if generator_id == &"":
			continue
		_generators_by_id[String(generator_id)] = generator

	var seen_goal_ids: Dictionary = {}
	for goal in GameState.get_all_goals():
		if goal == null or not goal.has_id():
			continue
		
		var goal_key: String = String(goal.id)
		if seen_goal_ids.has(goal_key):
			continue
		
		var target_generator_id: StringName = _find_generator_for_goal(goal)
		if target_generator_id.is_empty():
			continue
		
		seen_goal_ids[goal_key] = true
		_loaded_goals.append(GoalDefinition.new(target_generator_id, goal))

func _build_goal_rows() -> void:
	_rows_by_goal_id.clear()
	for child in _goals_list.get_children():
		child.queue_free()

	for goal in _loaded_goals:
		if goal.goal == null:
			continue

		var row_container: HBoxContainer = HBoxContainer.new()
		row_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
		row_container.add_theme_constant_override("separation", 12)

		var title_label: Label = Label.new()
		title_label.custom_minimum_size = Vector2(220.0, 0.0)
		title_label.text = "%s -> %s" % [String(goal.goal.id), String(goal.target_generator_id)]

		var status_label: Label = Label.new()
		status_label.custom_minimum_size = Vector2(95.0, 0.0)

		var requirements_label: Label = Label.new()
		requirements_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL

		var unlock_button: Button = Button.new()
		unlock_button.custom_minimum_size = Vector2(90.0, 0.0)
		unlock_button.text = "Unlock"
		unlock_button.disabled = true
		unlock_button.pressed.connect(_on_unlock_pressed.bind(goal.goal.id))

		row_container.add_child(title_label)
		row_container.add_child(status_label)
		row_container.add_child(requirements_label)
		row_container.add_child(unlock_button)
		_goals_list.add_child(row_container)

		_rows_by_goal_id[String(goal.goal.id)] = GoalRow.new(goal, status_label, requirements_label, unlock_button)

func _refresh_ui() -> void:
	if _loaded_goals.is_empty():
		_summary_label.text = "No valid goals loaded"
		return

	var ready_to_unlock: int = 0
	var unlocked: int = 0
	for goal in _loaded_goals:
		if goal.goal == null:
			continue

		var row: GoalRow = _rows_by_goal_id.get(String(goal.goal.id))
		if row == null:
			continue
		_refresh_goal_row(row)

		if _is_goal_completed(goal):
			unlocked += 1
		elif _is_goal_met(goal):
			ready_to_unlock += 1

	_summary_label.text = "Goals: %d | Ready: %d | Unlocked: %d" % [_loaded_goals.size(), ready_to_unlock, unlocked]

func _refresh_goal_row(row: GoalRow) -> void:
	var goal: GoalDefinition = row.goal
	var already_unlocked: bool = _is_goal_completed(goal)
	var can_resolve_target: bool = _can_resolve_target(goal.target_generator_id)
	var met: bool = _is_goal_met(goal)
	var can_click: bool = can_resolve_target and met and not already_unlocked

	row.requirements_label.text = _get_requirements_text(goal)
	row.button.disabled = not can_click
	if already_unlocked:
		row.button.text = "Done"
	else:
		row.button.text = "Unlock"

	if already_unlocked:
		row.status_label.text = "Unlocked"
		return

	if not can_resolve_target:
		row.status_label.text = "Missing"
		return

	if met:
		row.status_label.text = "Ready"
		return

	row.status_label.text = "Locked"

func _is_goal_met(goal: GoalDefinition) -> bool:
	if goal == null:
		return false
	if goal.goal == null:
		return false

	return bool(goal.goal.is_met())

func _is_goal_completed(goal: GoalDefinition) -> bool:
	if goal.goal == null or goal.goal.id.is_empty():
		return false
	return GameState.is_goal_completed(goal.goal.id)

func _on_unlock_pressed(goal_id: StringName) -> void:
	var row: GoalRow = _rows_by_goal_id.get(String(goal_id))
	if row == null:
		return

	var goal: GoalDefinition = row.goal
	if _is_goal_completed(goal):
		return
	if not _can_resolve_target(goal.target_generator_id):
		return
	if not _is_goal_met(goal):
		return

	var generator: CurrencyGenerator = _get_generator_for_goal(goal)
	if generator == null:
		return

	GameState.set_generator_unlocked(goal.target_generator_id, true)
	GameState.set_generator_available(goal.target_generator_id, true)
	if goal.goal.unlock_behavior == GoalData.UnlockBehavior.MANUAL:
		GameState._complete_goal_manually(goal.goal.id)

	print("[GoalsDebugUI] Unlocked goal '%s' -> %s" % [String(goal.goal.id), String(goal.target_generator_id)])
	_refresh_ui()

func _can_resolve_target(target_generator_id: StringName) -> bool:
	var target_key: String = String(target_generator_id)
	if target_key.is_empty():
		return false

	if _known_generator_ids.has(target_key) or GameState.generator_states.has(target_key):
		return true

	if not _warned_unknown_target_ids.has(target_key):
		_warned_unknown_target_ids[target_key] = true
		push_warning("Goals debug UI target generator not found in scene/state: '%s'" % target_key)
	return false

func _collect_known_generator_ids() -> void:
	_known_generator_ids.clear()
	_generators_by_id.clear()

	var scene_root: Node = get_tree().current_scene
	var search_root: Node = scene_root if scene_root != null else self
	var generator_nodes: Array[Node] = search_root.find_children("*", "CurrencyGenerator", true, false)
	for generator_node in generator_nodes:
		var generator: CurrencyGenerator = generator_node as CurrencyGenerator
		if generator == null:
			continue

		var generator_key: String = String(generator.get_generator_id())
		if generator_key.is_empty():
			continue

		_known_generator_ids[generator_key] = true
		_generators_by_id[generator_key] = generator

func _refresh_generator_lookup(generator_id: StringName) -> void:
	var generator_key: String = String(generator_id)
	if generator_key.is_empty():
		return

	var scene_root: Node = get_tree().current_scene
	var search_root: Node = scene_root if scene_root != null else self
	var generator_nodes: Array[Node] = search_root.find_children("*", "CurrencyGenerator", true, false)
	for generator_node in generator_nodes:
		var generator: CurrencyGenerator = generator_node as CurrencyGenerator
		if generator == null:
			continue
		if generator.get_generator_id() != generator_id:
			continue

		_generators_by_id[generator_key] = generator
		return

func _get_generator_for_goal(goal: GoalDefinition) -> CurrencyGenerator:
	if goal == null:
		return null

	var key: String = String(goal.target_generator_id)
	if key.is_empty():
		return null

	return _generators_by_id.get(key) as CurrencyGenerator

func _find_generator_for_goal(goal: GoalData) -> StringName:
	for generator_id in _generators_by_id.keys():
		var generator: CurrencyGenerator = _generators_by_id[generator_id]
		if generator == null or generator.data == null:
			continue
		if generator.data.has_unlock_goal():
			if String(generator.data.get_unlock_goal_id()) == String(goal.id):
				return StringName(generator_id)
	return &""

func _get_requirements_text(goal: GoalDefinition) -> String:
	if goal == null:
		return ""
	if goal.goal == null:
		return ""
	if goal.goal.get_script() != GOAL_DATA_SCRIPT:
		return ""

	var parts: Array[String] = []
	for requirement_resource in goal.goal.get_valid_requirements():
		if requirement_resource == null:
			continue
		if requirement_resource.get_script() != GOAL_REQUIREMENT_SCRIPT:
			continue

		var requirement_currency_id: StringName = requirement_resource.get_currency_id()
		var total_amount: BigNumber = GameState.get_total_currency_acquired_by_id(requirement_currency_id)
		var required_amount: BigNumber = requirement_resource.get_amount()
		parts.append(
			"%s %s / %s" % [
				_currency_label(requirement_currency_id),
				total_amount.to_string_suffix(2),
				required_amount.to_string_suffix(2)
			]
		)
	
	if parts.is_empty():
		return "No requirements"
	return " | ".join(parts)

func _currency_label(currency_id: StringName) -> String:
	return GameState.get_currency_name(currency_id)
