@tool
class_name CutsceneGraphEdit
extends GraphEdit

# Main graph editor interface

# Signals
signal node_added(node)
signal node_removed(node)
signal connection_created(from_node, from_port, to_node, to_port)
signal connection_removed(from_node, from_port, to_node, to_port)
signal graph_changed()

# Properties
var node_counter: int = 0  # For generating unique node IDs
var current_cutscene: CutsceneResource  # The cutscene being edited

# Preview properties
var preview_manager: PreviewManager
var preview_panel: PreviewPanel

# Undo/Redo properties
var undo_redo_manager: UndoRedoManager

# Called when the node is ready
func _ready() -> void:
	# Set up GraphEdit properties
	set_right_disconnects(true)
	set_show_grid(true)
	set_snapping_enabled(true)
	set_snapping_distance(20)
	
	# Connect to GraphEdit signals
	connect("connection_request", _on_connection_request)
	connect("disconnection_request", _on_disconnection_request)
	connect("node_selected", _on_node_selected)
	connect("node_unselected", _on_node_unselected)
	connect("popup_request", _on_popup_request)
	connect("connection_to_empty", _on_connection_to_empty)
	connect("connection_from_empty", _on_connection_from_empty)
	
	
	# Add mini-map
	_setup_minimap()


# Set up mini-map
func _setup_minimap() -> void:
	# Enable mini-map
	set_minimap_enabled(true)
	set_minimap_size(Vector2(200, 150))
	#set_minimap_offset(Vector2(10, 10))

# Add a new node to the graph
func add_node(node_type: String, position: Vector2) -> BaseGraphNode:
	var new_node: BaseGraphNode
	
	match node_type:
		"entry":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/EntryNode.gd").new()
		"exit":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/ExitNode.gd").new()
		"move":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/MoveActionNode.gd").new()
		"turn":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/TurnActionNode.gd").new()
		"dialogue":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/DialogueActionNode.gd").new()
		"animation":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/AnimationActionNode.gd").new()
		"wait":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/WaitActionNode.gd").new()
		"parallel":
			new_node = preload("res://addons/cutscene_editor/editor/nodes/ParallelGroupNode.gd").new()
		_:
			return null
	
	# Set node position
	new_node.position_offset = position
	
	# Special handling for parallel groups
	if new_node is ParallelGroupNode:
		# Set a larger initial size for parallel groups
		new_node.custom_minimum_size = Vector2(200, 150)
	
	# Add to GraphEdit
	add_child(new_node)
	
	# Connect node signals
	new_node.connect("node_selected", _on_graph_node_selected)
	new_node.connect("node_deleted", _on_graph_node_deleted)
	new_node.connect("parameter_changed", _on_node_parameter_changed)
	
	# Emit signal
	emit_signal("node_added", new_node)
	emit_signal("graph_changed")
	
	return new_node

# Handle connection requests
func _on_connection_request(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	# Validate connection before creating it
	if _is_connection_valid(from_node, from_port, to_node, to_port):
		# Get node references
		var from_node_instance = get_node_or_null(from_node)
		var to_node_instance = get_node_or_null(to_node)
		
		# Special handling for parallel groups
		if to_node_instance is ParallelGroupNode:
			# Connecting to a parallel group
			if _is_valid_parallel_connection(from_node_instance, from_port, to_node_instance, to_port):
				# Add child node to parallel group
				if to_node_instance.can_add_child_node(from_node_instance):
					to_node_instance.add_child_node(from_node_instance)
					
					# Create a logical connection (not visual)
					_create_logical_parallel_connection(from_node, from_port, to_node, to_port)
					
					# Emit signal
					emit_signal("connection_created", from_node, from_port, to_node, to_port)
					emit_signal("graph_changed")
					return
		
		# Create the connection
		connect_node(from_node, from_port, to_node, to_port)
		
		# Emit signal
		emit_signal("connection_created", from_node, from_port, to_node, to_port)
		emit_signal("graph_changed")
	else:
		# Show error feedback
		_show_connection_error(from_node, from_port, to_node, to_port)

# Handle disconnection requests
func _on_disconnection_request(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	# Get node references
	var from_node_instance = get_node_or_null(from_node)
	var to_node_instance = get_node_or_null(to_node)
	
	# Special handling for parallel groups
	if to_node_instance is ParallelGroupNode:
		# Remove child node from parallel group
		if from_node_instance in to_node_instance.child_nodes:
			to_node_instance.remove_child_node(from_node_instance)
			
			# Remove logical connection
			_remove_logical_parallel_connection(from_node, from_port, to_node, to_port)
			
			# Emit signal
			emit_signal("connection_removed", from_node, from_port, to_node, to_port)
			emit_signal("graph_changed")
			return
	
	# Remove the connection
	disconnect_node(from_node, from_port, to_node, to_port)
	
	# Emit signal
	emit_signal("connection_removed", from_node, from_port, to_node, to_port)
	emit_signal("graph_changed")

# Validate if a connection is valid
func _is_connection_valid(from_node_name: String, from_port: int, to_node_name: String, to_port: int) -> bool:
	# Get node references
	var from_node = get_node_or_null(from_node_name)
	var to_node = get_node_or_null(to_node_name)
	
	if not from_node or not to_node:
		return false
	
	# Prevent connections to self
	if from_node == to_node:
		return false
	
	# Prevent duplicate connections
	if is_node_connected(from_node_name, from_port, to_node_name, to_port):
		return false
	
	# Prevent circular dependencies
	if _would_create_cycle(from_node_name, to_node_name):
		return false
	
	# Validate connection based on node types
	match from_node.node_type:
		"entry":
			# Entry can connect to any node except entry/exit
			return to_node.node_type != "entry" and to_node.node_type != "exit"
		"exit":
			# Exit cannot have outgoing connections
			return false
		"parallel":
			# Parallel group output can connect to any node except entry/parallel
			if from_port == from_node.input_connections:  # Output port
				return to_node.node_type != "entry" and to_node.node_type != "parallel"
			else:  # Input port
				return to_node.node_type != "exit" and to_node.node_type != "parallel"
		_:
			# Other nodes can connect to any node except entry
			return to_node.node_type != "entry"
	
	return true

# Check if creating a connection would create a cycle
func _would_create_cycle(from_node_name: String, to_node_name: String) -> bool:
	# Simple cycle detection using depth-first search
	var visited = {}
	var recursion_stack = {}
	
	# Start from the target node and see if we can reach the source node
	return _dfs_cycle_check(to_node_name, from_node_name, visited, recursion_stack)

# Depth-first search for cycle detection
func _dfs_cycle_check(current_node_name: String, target_node_name: String, visited: Dictionary, recursion_stack: Dictionary) -> bool:
	# Mark current node as visited and add to recursion stack
	visited[current_node_name] = true
	recursion_stack[current_node_name] = true
	
	# Check all outgoing connections
	for connection in get_connection_list():
		if connection["from_node"] == current_node_name:
			var next_node_name = connection["to_node"]
			
			# If we reached the target node, we found a cycle
			if next_node_name == target_node_name:
				return true
			
			# If next node not visited, recursively check
			if not visited.has(next_node_name):
				if _dfs_cycle_check(next_node_name, target_node_name, visited, recursion_stack):
					return true
			# If next node is in recursion stack, we found a cycle
			elif recursion_stack.has(next_node_name):
				return true
	
	# Check parallel connections
	if has_meta("logical_connections"):
		var logical_connections = get_meta("logical_connections")
		for connection in logical_connections:
			if connection["from_node"] == current_node_name:
				var next_node_name = connection["to_node"]
				
				# If we reached the target node, we found a cycle
				if next_node_name == target_node_name:
					return true
				
				# If next node not visited, recursively check
				if not visited.has(next_node_name):
					if _dfs_cycle_check(next_node_name, target_node_name, visited, recursion_stack):
						return true
				# If next node is in recursion stack, we found a cycle
				elif recursion_stack.has(next_node_name):
					return true
	
	# Remove from recursion stack
	recursion_stack[current_node_name] = false
	return false

# Show connection error feedback
func _show_connection_error(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	# Visual feedback for invalid connection
	# This could be a temporary red highlight or a popup message
	print("Invalid connection: %s -> %s" % [from_node, to_node])

# Handle popup request (right-click context menu)
func _on_popup_request(position: Vector2) -> void:
	# Create context menu for adding nodes
	var menu = PopupMenu.new()
	menu.name = "NodeContextMenu"
	
	# Add node types to menu
	menu.add_item("Add Entry Node", 0)
	menu.add_item("Add Exit Node", 1)
	menu.add_item("Add Move Action", 2)
	menu.add_item("Add Turn Action", 3)
	menu.add_item("Add Dialogue Action", 4)
	menu.add_item("Add Animation Action", 5)
	menu.add_item("Add Wait Action", 6)
	menu.add_item("Add Parallel Group", 7)
	
	# Connect menu signals
	menu.connect("id_pressed", _on_context_menu_selected.bind(position))
	
	# Add menu to scene and show it
	add_child(menu)
	menu.position = position
	menu.popup()

# Handle context menu selection
func _on_context_menu_selected(id: int, position: Vector2) -> void:
	var node_type: String
	
	match id:
		0:
			node_type = "entry"
		1:
			node_type = "exit"
		2:
			node_type = "move"
		3:
			node_type = "turn"
		4:
			node_type = "dialogue"
		5:
			node_type = "animation"
		6:
			node_type = "wait"
		7:
			node_type = "parallel"
		_:
			return
	
	# Add the selected node type
	add_node(node_type, position)

# Handle zoom in
func _on_zoom_in_pressed() -> void:
	# Increase zoom level
	zoom *= 1.2
	_update_zoom_label()

# Handle zoom out
func _on_zoom_out_pressed() -> void:
	# Decrease zoom level
	zoom /= 1.2
	_update_zoom_label()

# Update zoom label
func _update_zoom_label() -> void:
	var zoom_label = get_node_or_null("ZoomControls/ZoomLabel")
	if zoom_label:
		zoom_label.text = "%d%%" % (zoom * 100)

# Handle node selection
func _on_node_selected(node_name: String) -> void:
	# Handle GraphEdit's built-in node selection
	pass

# Handle node unselection
func _on_node_unselected(node_name: String) -> void:
	# Handle GraphEdit's built-in node unselection
	pass

# Handle graph node selection
func _on_graph_node_selected(node: BaseGraphNode) -> void:
	# Handle custom node selection
	pass

# Handle graph node deletion
func _on_graph_node_deleted(node: BaseGraphNode) -> void:
	# Special handling for parallel groups
	if node is ParallelGroupNode:
		# Remove all child nodes first
		for child_node in node.child_nodes:
			# Remove child from scene tree
			if child_node.get_parent():
				child_node.get_parent().remove_child(child_node)
			
			# Add child back to main graph
			add_child(child_node)
			
			# Update child position to be near the parallel group
			child_node.position_offset = node.position_offset + Vector2(50, 50)
		
		# Clear child nodes array
		node.child_nodes.clear()
	
	# Remove all connections to/from this node
	var connections = get_connection_list()
	for connection in connections:
		if connection["from_node"] == node.name or connection["to_node"] == node.name:
			disconnect_node(connection["from_node"], connection["from_port"], connection["to_node"], connection["to_port"])
	
	# Remove logical connections for parallel groups
	if has_meta("logical_connections"):
		var logical_connections = get_meta("logical_connections")
		var i = 0
		while i < logical_connections.size():
			var conn = logical_connections[i]
			if conn["from_node"] == node.name or conn["to_node"] == node.name:
				logical_connections.remove_at(i)
			else:
				i += 1
	
	# Remove node from GraphEdit
	remove_child(node)
	
	# Emit signals
	emit_signal("node_removed", node)
	emit_signal("graph_changed")

# Handle node parameter changes
func _on_node_parameter_changed(node: BaseGraphNode, parameter_name: String, new_value) -> void:
	# Handle parameter changes in nodes
	emit_signal("graph_changed")

# Handle connection to empty space
func _on_connection_to_empty(from_node: String, from_port: int, release_position: Vector2) -> void:
	# This could be used to show a menu or create a new node
	pass

# Handle connection from empty space
func _on_connection_from_empty(to_node: String, to_port: int, release_position: Vector2) -> void:
	# This could be used to show a menu or create a new node
	pass

# Clear the graph
func clear_graph() -> void:
	# Remove all nodes
	for child in get_children():
		if child is BaseGraphNode:
			remove_child(child)
			child.queue_free()
	
	# Clear all connections
	clear_connections()
	
	# Reset node counter
	node_counter = 0
	
	# Emit signal
	emit_signal("graph_changed")

# Load graph from cutscene resource
func load_from_cutscene(cutscene: CutsceneResource) -> void:
	# Clear existing graph
	clear_graph()
	
	# Set current cutscene
	current_cutscene = cutscene
	
	# Create nodes from cutscene data
	for node_data in cutscene.nodes:
		var node = add_node(node_data["type"], Vector2(node_data["x"], node_data["y"]))
		if node:
			node.name = node_data["name"]
			# Set node parameters
			for param_name in node_data["parameters"]:
				node.set_parameter(param_name, node_data["parameters"][param_name])
	
	# Create connections from cutscene data
	for connection_data in cutscene.connections:
		connect_node(connection_data["from_node"], connection_data["from_port"], 
					 connection_data["to_node"], connection_data["to_port"])
	
	# Emit signal
	emit_signal("graph_changed")

# Save graph to cutscene resource
func save_to_cutscene() -> CutsceneResource:
	if not current_cutscene:
		current_cutscene = preload("res://addons/cutscene_editor/editor/resources/CutsceneResource.gd").new()
	
	# Clear existing data
	current_cutscene.nodes.clear()
	current_cutscene.connections.clear()
	
	# Save nodes
	for child in get_children():
		if child is BaseGraphNode:
			var node_data = {
				"name": child.name,
				"type": child.node_type,
				"x": child.position_offset.x,
				"y": child.position_offset.y,
				"parameters": child.action_parameters
			}
			current_cutscene.nodes.append(node_data)
	
	# Save connections
	for connection in get_connection_list():
		var connection_data = {
			"from_node": connection["from_node"],
			"from_port": connection["from_port"],
			"to_node": connection["to_node"],
			"to_port": connection["to_port"]
		}
		current_cutscene.connections.append(connection_data)
	
	return current_cutscene

# Special handling for parallel groups
func _is_valid_parallel_connection(from_node: BaseGraphNode, from_port: int, to_node: ParallelGroupNode, to_port: int) -> bool:
	# Can only connect to input ports of parallel groups
	if to_port >= to_node.input_connections:
		return false
	
	# Can't connect parallel group to itself
	if from_node == to_node:
		return false
	
	# Can't connect entry or exit nodes to parallel groups
	if from_node.node_type == "entry" or from_node.node_type == "exit":
		return false
	
	# Can't connect parallel groups to parallel groups
	if from_node.node_type == "parallel":
		return false
	
	return true

# Create a logical connection for parallel groups (not visually represented)
func _create_logical_parallel_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	# Store the logical connection in our data structure
	# This connection won't be visually represented but will be used for generation
	var logical_connection = {
		"from_node": from_node,
		"from_port": from_port,
		"to_node": to_node,
		"to_port": to_port,
		"is_parallel": true
	}
	
	# Add to a separate list of logical connections
	if not has_meta("logical_connections"):
		set_meta("logical_connections", [])
	
	var logical_connections = get_meta("logical_connections")
	logical_connections.append(logical_connection)

# Remove a logical connection for parallel groups
func _remove_logical_parallel_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	if not has_meta("logical_connections"):
		return
	
	var logical_connections = get_meta("logical_connections")
	var i = 0
	while i < logical_connections.size():
		var conn = logical_connections[i]
		if (conn["from_node"] == from_node and conn["from_port"] == from_port and
			conn["to_node"] == to_node and conn["to_port"] == to_port):
			logical_connections.remove_at(i)
			return
		i += 1

# Get all logical connections
func get_logical_connections() -> Array:
	if has_meta("logical_connections"):
		return get_meta("logical_connections")
	return []

# Set up preview system
func setup_preview() -> void:
	# Create preview manager
	preview_manager = PreviewManager.new()
	add_child(preview_manager)
	
	# Create preview panel
	preview_panel = PreviewPanel.new()
	preview_panel.set_preview_manager(preview_manager)
	preview_panel.set_graph_edit(self)
	
	# Add to editor interface (this would be added to the editor UI)
	# For now, we'll just keep a reference to it

# Start preview
func start_preview() -> void:
	if preview_manager:
		preview_manager.start_preview()

# Stop preview
func stop_preview() -> void:
	if preview_manager:
		preview_manager.stop_preview()

# Pause preview
func pause_preview() -> void:
	if preview_manager:
		preview_manager.pause_preview()

# Resume preview
func resume_preview() -> void:
	if preview_manager:
		preview_manager.resume_preview()

# Set up undo/redo system
func _setup_undo_redo() -> void:
	# Create undo/redo manager
	undo_redo_manager = UndoRedoManager.new()
	undo_redo_manager.connect("undo_redo_state_changed", _on_undo_redo_state_changed)
	
	# Connect to existing signals
	connect("node_added", _on_node_added_for_undo)
	connect("node_removed", _on_node_removed_for_undo)
	connect("connection_created", _on_connection_created_for_undo)
	connect("connection_removed", _on_connection_removed_for_undo)
	connect("graph_changed", _on_graph_changed_for_undo)

# Handle node added for undo
func _on_node_added_for_undo(node: BaseGraphNode) -> void:
	if undo_redo_manager:
		var operation = undo_redo_manager.create_node_added_operation(node)
		undo_redo_manager.add_operation(operation)

# Handle node removed for undo
func _on_node_removed_for_undo(node: BaseGraphNode) -> void:
	if undo_redo_manager:
		var operation = undo_redo_manager.create_node_removed_operation(node)
		undo_redo_manager.add_operation(operation)

# Handle connection created for undo
func _on_connection_created_for_undo(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	if undo_redo_manager:
		var operation = undo_redo_manager.create_connection_created_operation(from_node, from_port, to_node, to_port)
		undo_redo_manager.add_operation(operation)

# Handle connection removed for undo
func _on_connection_removed_for_undo(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
	if undo_redo_manager:
		var operation = undo_redo_manager.create_connection_removed_operation(from_node, from_port, to_node, to_port)
		undo_redo_manager.add_operation(operation)

# Handle graph changed for undo
func _on_graph_changed_for_undo() -> void:
	# This could be used for batch operations or complex changes
	pass

# Handle undo/redo state changed
func _on_undo_redo_state_changed() -> void:
	# Update UI to reflect undo/redo availability
	_update_undo_redo_ui()

# Update undo/redo UI
func _update_undo_redo_ui() -> void:
	# This would update toolbar buttons or menu items
	pass

# Perform undo operation
func undo() -> void:
	if undo_redo_manager and undo_redo_manager.can_undo():
		undo_redo_manager.undo()

# Perform redo operation
func redo() -> void:
	if undo_redo_manager and undo_redo_manager.can_redo():
		undo_redo_manager.redo()