NodeFlowEvents<T>({
  NodeEvents<T>? node,
  PortEvents<T>? port,
  ConnectionEvents<T>? connection,
  ViewportEvents? viewport,
  AnnotationEvents? annotation,
  ValueChanged<SelectionState<T>>? onSelectionChange,
  VoidCallback? onInit,
  ValueChanged<FlowError>? onError,
})

NodeEvents<T>({
  ValueChanged<Node<T>>? onCreated,
  ValueChanged<Node<T>>? onDeleted,
  ValueChanged<Node<T>?>? onSelected,
  ValueChanged<Node<T>>? onTap,
  ValueChanged<Node<T>>? onDoubleTap,
  void Function(Node<T>, Offset)? onContextMenu,
  ValueChanged<Node<T>>? onDragStart,
  ValueChanged<Node<T>>? onDrag,
  ValueChanged<Node<T>>? onDragStop,
  ValueChanged<Node<T>>? onMouseEnter,
  ValueChanged<Node<T>>? onMouseLeave,
})

NodeEvents<MyData>(
  onTap: (node) => print('Tapped: ${node.id}'),
  onDoubleTap: (node) => _editNode(node),
  onDragStop: (node) => _savePosition(node),
  onContextMenu: (node, pos) => _showMenu(node, pos),
)

PortEvents<T>({
  void Function(Node<T>, Port, bool)? onTap,
  void Function(Node<T>, Port, bool)? onDoubleTap,
  void Function(Node<T>, Port, bool)? onMouseEnter,
  void Function(Node<T>, Port, bool)? onMouseLeave,
  void Function(Node<T>, Port, bool, Offset)? onContextMenu,
})

PortEvents<MyData>(
  onTap: (node, port, isOutput) {
    print('Tapped ${isOutput ? 'output' : 'input'} port: ${port.id}');
  },
  onMouseEnter: (node, port, isOutput) => _showTooltip(port),
  onMouseLeave: (node, port, isOutput) => _hideTooltip(),
)

ConnectionEvents<T>({
  ValueChanged<Connection>? onCreated,
  ValueChanged<Connection>? onDeleted,
  ValueChanged<Connection?>? onSelected,
  ValueChanged<Connection>? onTap,
  ValueChanged<Connection>? onDoubleTap,
  ValueChanged<Connection>? onMouseEnter,
  ValueChanged<Connection>? onMouseLeave,
  void Function(Connection, Offset)? onContextMenu,
  void Function(String nodeId, String portId, bool isOutput)? onConnectStart,
  void Function(bool success)? onConnectEnd,
  ConnectionValidationResult Function(ConnectionStartContext<T>)? onBeforeStart,
  ConnectionValidationResult Function(ConnectionCompleteContext<T>)? onBeforeComplete,
})

class ConnectionStartContext<T> {
  final Node<T> sourceNode;
  final Port sourcePort;
  final List<String> existingConnections;

  // Computed properties
  bool get isOutputPort;
  bool get isInputPort;
}

class ConnectionCompleteContext<T> {
  final Node<T> sourceNode;
  final Port sourcePort;
  final Node<T> targetNode;
  final Port targetPort;
  final List<String> existingSourceConnections;
  final List<String> existingTargetConnections;

  // Computed properties
  bool get isOutputToInput;
  bool get isInputToOutput;
  bool get isSelfConnection;
  bool get isSamePort;
}

class ConnectionValidationResult {
  final bool allowed;
  final String? reason;
  final bool showMessage;

  // Factory constructors
  const ConnectionValidationResult.allow();
  const ConnectionValidationResult.deny({String? reason, bool showMessage = false});
}

ConnectionEvents<MyData>(
  onBeforeStart: (context) {
    // Validate port can start connections
    if (!context.sourcePort.isConnectable) {
      return ConnectionValidationResult.deny(
        reason: 'Port is not connectable',
        showMessage: true,
      );
    }
    return ConnectionValidationResult.allow();
  },
  onBeforeComplete: (context) {
    // Prevent self-connections
    if (context.isSelfConnection) {
      return ConnectionValidationResult.deny(
        reason: 'Cannot connect to same node',
        showMessage: true,
      );
    }
    // Only allow output-to-input
    if (!context.isOutputToInput) {
      return ConnectionValidationResult.deny(
        reason: 'Must connect output to input',
      );
    }
    return ConnectionValidationResult.allow();
  },
)

ViewportEvents({
  ValueChanged<GraphViewport>? onMoveStart,
  ValueChanged<GraphViewport>? onMove,
  ValueChanged<GraphViewport>? onMoveEnd,
  ValueChanged<Offset>? onCanvasTap,
  ValueChanged<Offset>? onCanvasDoubleTap,
  ValueChanged<Offset>? onCanvasContextMenu,
})

ViewportEvents(
  onCanvasTap: (pos) => controller.clearSelection(),
  onCanvasDoubleTap: (pos) => _addNodeAt(pos),
  onCanvasContextMenu: (pos) => _showAddMenu(pos),
  onMove: (viewport) => _updateMinimap(viewport),
)

AnnotationEvents({
  ValueChanged<Annotation>? onCreated,
  ValueChanged<Annotation>? onDeleted,
  ValueChanged<Annotation?>? onSelected,
  ValueChanged<Annotation>? onTap,
  ValueChanged<Annotation>? onDoubleTap,
  void Function(Annotation, Offset)? onContextMenu,
  ValueChanged<Annotation>? onMouseEnter,
  ValueChanged<Annotation>? onMouseLeave,
})

class SelectionState<T> {
  final List<Node<T>> nodes;
  final List<Connection> connections;
  final List<Annotation> annotations;

  bool get hasSelection;
}

onSelectionChange: (state) {
  if (state.hasSelection) {
    _showSelectionToolbar(state);
    print('Selected ${state.nodes.length} nodes');
  } else {
    _hideSelectionToolbar();
  }
}

class FlowError {
  final String message;
  final Object? error;
  final StackTrace? stackTrace;
}

onError: (error) {
  print('Flow error: ${error.message}');
  if (error.error != null) {
    print('Caused by: ${error.error}');
  }
}

NodeFlowEditor<WorkflowData>(
  controller: controller,
  events: NodeFlowEvents(
    node: NodeEvents(
      onTap: (node) => setState(() => _selected = node),
      onDoubleTap: (node) => _editNode(node),
      onDragStop: (node) => _log('Moved: ${node.id}'),
      onContextMenu: (node, pos) => _showNodeMenu(node, pos),
    ),
    port: PortEvents(
      onMouseEnter: (node, port, _) => _showPortInfo(port),
      onMouseLeave: (_, __, ___) => _hidePortInfo(),
    ),
    connection: ConnectionEvents(
      onCreated: (conn) => _log('Connected: ${conn.id}'),
      onDeleted: (conn) => _log('Disconnected: ${conn.id}'),
      onMouseEnter: (conn) => conn.animated = true,
      onMouseLeave: (conn) => conn.animated = false,
      onBeforeComplete: (ctx) => _validateConnection(ctx),
    ),
    viewport: ViewportEvents(
      onCanvasTap: (_) => controller.clearSelection(),
      onCanvasContextMenu: (pos) => _showAddNodeMenu(pos),
    ),
    onSelectionChange: (state) {
      setState(() => _selectionCount = state.nodes.length);
    },
    onInit: () => _log('Editor ready'),
    onError: (error) => _log('Error: ${error.message}'),
  ),
)

final baseEvents = NodeFlowEvents<MyData>(
  node: NodeEvents(onTap: (n) => print('tap')),
);

final extendedEvents = baseEvents.copyWith(
  connection: ConnectionEvents(onCreated: (c) => print('created')),
);