workflow_canvas.py

"""
Graphics Scene and View for workflow canvas with zoom and pan support.
"""

from PyQt5.QtWidgets import QGraphicsScene, QGraphicsView, QMenu, QAction
from PyQt5.QtCore import Qt, QPointF, pyqtSignal
from PyQt5.QtGui import QPainter, QWheelEvent, QMouseEvent, QKeyEvent
from node import Node, NodeType, NodeRegistry
from graphics_items import GraphicsNode, GraphicsConnection
from workflow_graph import WorkflowGraph


class WorkflowScene(QGraphicsScene):
    """Graphics scene for the workflow canvas."""
    
    # Signals
    node_selected = pyqtSignal(Node)
    connection_added = pyqtSignal(str, str)
    
    def __init__(self, workflow_graph: WorkflowGraph, parent=None):
        super().__init__(parent)
        self.workflow_graph = workflow_graph
        
        # Visual elements
        self.graphics_nodes = {}  # Map node_id -> GraphicsNode
        self.graphics_connections = []  # List of GraphicsConnection
        
        # Connection creation state
        self.temp_connection_start = None
        self.temp_connection_line = None
        
        # Set scene size
        self.setSceneRect(-2000, -2000, 4000, 4000)
        
        # Draw grid background
        self.setBackgroundBrush(Qt.white)
    
    def add_node_at_position(self, node_type: NodeType, pos: QPointF):
        """Add a new node at the specified position."""
        # Create logical node
        node = NodeRegistry.create_node(node_type, x=pos.x(), y=pos.y())
        
        # Add to graph
        if not self.workflow_graph.add_node(node):
            return None
        
        # Create visual representation
        graphics_node = GraphicsNode(node)
        self.addItem(graphics_node)
        self.graphics_nodes[node.id] = graphics_node
        
        return node
    
    def remove_selected_items(self):
        """Remove selected nodes and connections."""
        selected_items = self.selectedItems()
        
        for item in selected_items:
            if isinstance(item, GraphicsNode):
                # Remove node from graph
                node_id = item.node.id
                self.workflow_graph.remove_node(node_id)
                
                # Remove visual elements
                if node_id in self.graphics_nodes:
                    self.removeItem(self.graphics_nodes[node_id])
                    del self.graphics_nodes[node_id]
                
                # Remove associated connections
                self.graphics_connections = [conn for conn in self.graphics_connections
                                            if conn.from_node != item and conn.to_node != item]
            
            elif isinstance(item, GraphicsConnection):
                # Remove connection from graph
                from_id = item.from_node.node.id
                to_id = item.to_node.node.id
                self.workflow_graph.remove_connection(from_id, to_id)
                
                # Remove visual element
                self.removeItem(item)
                if item in self.graphics_connections:
                    self.graphics_connections.remove(item)
    
    def add_connection(self, from_node: GraphicsNode, to_node: GraphicsNode) -> bool:
        """Add a connection between two nodes."""
        from_id = from_node.node.id
        to_id = to_node.node.id
        
        # Add to logical graph
        success, error_msg = self.workflow_graph.add_connection(from_id, to_id)
        
        if not success:
            print(f"Cannot add connection: {error_msg}")
            return False
        
        # Create visual connection
        graphics_conn = GraphicsConnection(from_node, to_node)
        self.addItem(graphics_conn)
        self.graphics_connections.append(graphics_conn)
        
        self.connection_added.emit(from_id, to_id)
        return True
    
    def update_connections(self):
        """Update all connection visuals (called when nodes move)."""
        for conn in self.graphics_connections:
            conn.update_position()
    
    def clear_workflow(self):
        """Clear all nodes and connections."""
        self.clear()
        self.graphics_nodes.clear()
        self.graphics_connections.clear()
        self.workflow_graph.clear()
    
    def rebuild_from_graph(self):
        """Rebuild visual elements from the workflow graph."""
        # Clear existing visual elements
        self.clear()
        self.graphics_nodes.clear()
        self.graphics_connections.clear()
        
        # Create graphics nodes
        for node in self.workflow_graph.nodes.values():
            graphics_node = GraphicsNode(node)
            self.addItem(graphics_node)
            self.graphics_nodes[node.id] = graphics_node
        
        # Create graphics connections
        for from_id, to_id in self.workflow_graph.connections:
            if from_id in self.graphics_nodes and to_id in self.graphics_nodes:
                from_node = self.graphics_nodes[from_id]
                to_node = self.graphics_nodes[to_id]
                graphics_conn = GraphicsConnection(from_node, to_node)
                self.addItem(graphics_conn)
                self.graphics_connections.append(graphics_conn)
    
    def mousePressEvent(self, event: QMouseEvent):
        """Handle mouse press for connection creation."""
        item = self.itemAt(event.scenePos(), self.views()[0].transform())
        
        if isinstance(item, GraphicsNode):
            # Emit node selected signal
            self.node_selected.emit(item.node)
            
            # Start connection creation with Ctrl+Click
            if event.button() == Qt.LeftButton and event.modifiers() == Qt.ControlModifier:
                self.temp_connection_start = item
                # Create a temporary line for visual feedback
                from PyQt5.QtWidgets import QGraphicsLineItem
                from PyQt5.QtGui import QPen
                self.temp_connection_line = QGraphicsLineItem()
                self.temp_connection_line.setPen(QPen(Qt.black, 2, Qt.DashLine))
                self.addItem(self.temp_connection_line)
                event.accept()
                return
        
        super().mousePressEvent(event)
    
    def mouseMoveEvent(self, event: QMouseEvent):
        """Handle mouse move for connection creation preview."""
        if self.temp_connection_start and self.temp_connection_line:
            # Update the temporary line
            start = self.temp_connection_start.get_output_point()
            end = event.scenePos()
            self.temp_connection_line.setLine(start.x(), start.y(), end.x(), end.y())
        
        super().mouseMoveEvent(event)
    
    def mouseReleaseEvent(self, event: QMouseEvent):
        """Handle mouse release for connection creation."""
        if self.temp_connection_start and event.button() == Qt.LeftButton:
            # Check if we released on a node
            item = self.itemAt(event.scenePos(), self.views()[0].transform())
            
            if isinstance(item, GraphicsNode) and item != self.temp_connection_start:
                # Create connection
                self.add_connection(self.temp_connection_start, item)
            
            # Clean up temporary line
            if self.temp_connection_line:
                self.removeItem(self.temp_connection_line)
                self.temp_connection_line = None
            self.temp_connection_start = None
            event.accept()
            return
        
        super().mouseReleaseEvent(event)
    
    def get_node_at_position(self, pos: QPointF) -> GraphicsNode:
        """Get the node at the specified position."""
        items = self.items(pos)
        for item in items:
            if isinstance(item, GraphicsNode):
                return item
        return None


class WorkflowView(QGraphicsView):
    """Graphics view with zoom and pan support."""
    
    def __init__(self, scene: WorkflowScene, parent=None):
        super().__init__(scene, parent)
        
        # View settings
        self.setRenderHint(QPainter.Antialiasing)
        self.setRenderHint(QPainter.TextAntialiasing)
        self.setDragMode(QGraphicsView.RubberBandDrag)
        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
        self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
        
        # Zoom settings
        self.zoom_factor = 1.0
        self.zoom_step = 1.15
        self.min_zoom = 0.3
        self.max_zoom = 3.0
        
        # Pan settings
        self.pan_active = False
        self.pan_start_pos = None
    
    def wheelEvent(self, event: QWheelEvent):
        """Handle mouse wheel for zooming."""
        # Get the mouse position in scene coordinates before zooming
        old_pos = self.mapToScene(event.pos())
        
        # Calculate zoom factor
        if event.angleDelta().y() > 0:
            zoom_factor = self.zoom_step
        else:
            zoom_factor = 1.0 / self.zoom_step
        
        # Check zoom limits
        new_zoom = self.zoom_factor * zoom_factor
        if new_zoom < self.min_zoom or new_zoom > self.max_zoom:
            return
        
        # Apply zoom
        self.scale(zoom_factor, zoom_factor)
        self.zoom_factor = new_zoom
        
        # Get the new position after zooming
        new_pos = self.mapToScene(event.pos())
        
        # Adjust view to keep the same point under the mouse
        delta = new_pos - old_pos
        self.translate(delta.x(), delta.y())
    
    def mousePressEvent(self, event: QMouseEvent):
        """Handle mouse press for panning."""
        if event.button() == Qt.MiddleButton:
            # Start panning
            self.pan_active = True
            self.pan_start_pos = event.pos()
            self.setCursor(Qt.ClosedHandCursor)
            event.accept()
        else:
            super().mousePressEvent(event)
    
    def mouseMoveEvent(self, event: QMouseEvent):
        """Handle mouse move for panning."""
        if self.pan_active:
            # Pan the view
            delta = event.pos() - self.pan_start_pos
            self.pan_start_pos = event.pos()
            
            self.horizontalScrollBar().setValue(
                self.horizontalScrollBar().value() - delta.x()
            )
            self.verticalScrollBar().setValue(
                self.verticalScrollBar().value() - delta.y()
            )
            event.accept()
        else:
            super().mouseMoveEvent(event)
    
    def mouseReleaseEvent(self, event: QMouseEvent):
        """Handle mouse release for panning."""
        if event.button() == Qt.MiddleButton and self.pan_active:
            # Stop panning
            self.pan_active = False
            self.setCursor(Qt.ArrowCursor)
            event.accept()
        else:
            super().mouseReleaseEvent(event)
    
    def keyPressEvent(self, event: QKeyEvent):
        """Handle key press events."""
        if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
            # Delete selected items
            self.scene().remove_selected_items()
        elif event.key() == Qt.Key_Plus or event.key() == Qt.Key_Equal:
            # Zoom in
            if self.zoom_factor * self.zoom_step <= self.max_zoom:
                self.scale(self.zoom_step, self.zoom_step)
                self.zoom_factor *= self.zoom_step
        elif event.key() == Qt.Key_Minus:
            # Zoom out
            if self.zoom_factor / self.zoom_step >= self.min_zoom:
                self.scale(1.0 / self.zoom_step, 1.0 / self.zoom_step)
                self.zoom_factor /= self.zoom_step
        elif event.key() == Qt.Key_0 and event.modifiers() == Qt.ControlModifier:
            # Reset zoom
            self.reset_zoom()
        else:
            super().keyPressEvent(event)
    
    def reset_zoom(self):
        """Reset zoom to 100%."""
        self.resetTransform()
        self.zoom_factor = 1.0
    
    def contextMenuEvent(self, event):
        """Show context menu."""
        scene_pos = self.mapToScene(event.pos())
        
        menu = QMenu(self)
        
        # Add node actions
        add_menu = menu.addMenu("Add Node")
        
        start_action = QAction("Start Node", self)
        start_action.triggered.connect(lambda: self.scene().add_node_at_position(NodeType.START, scene_pos))
        add_menu.addAction(start_action)
        
        process_action = QAction("Process Node", self)
        process_action.triggered.connect(lambda: self.scene().add_node_at_position(NodeType.PROCESS, scene_pos))
        add_menu.addAction(process_action)
        
        decision_action = QAction("Decision Node", self)
        decision_action.triggered.connect(lambda: self.scene().add_node_at_position(NodeType.DECISION, scene_pos))
        add_menu.addAction(decision_action)
        
        end_action = QAction("End Node", self)
        end_action.triggered.connect(lambda: self.scene().add_node_at_position(NodeType.END, scene_pos))
        add_menu.addAction(end_action)
        
        # Delete action if items are selected
        if self.scene().selectedItems():
            menu.addSeparator()
            delete_action = QAction("Delete Selected", self)
            delete_action.triggered.connect(self.scene().remove_selected_items)
            menu.addAction(delete_action)
        
        menu.exec_(event.globalPos())