// Edge added even if invalid
dag.addEdge(edge);

// Check validation state
const validation = dag.validateEdge(edge.id);
if (!validation.valid) {
  // Edge exists but is marked invalid
  if (validation.severity === "error") {
    // Type mismatch or cycle - show in red
  } else if (validation.severity === "restriction") {
    // Multiplicity violation - show in yellow
  }
}

import { DAGGraph, NodeTypeRegistry, EventEmitter } from "@cook-step/dag-graph";

// Create registry with node types
const registry = new NodeTypeRegistry();
registry.register("number", {
  inputs: [{ id: "in", schema: { type: "number" } }],
  outputs: [{ id: "out", schema: { type: "number" } }],
});

// Create DAG - Basic
const dag = new DAGGraph({ registry });

// Create DAG - With custom EventEmitter (for integration with other systems)
const sharedEventEmitter = new EventEmitter();
const dag = new DAGGraph({ 
  registry,
  eventEmitter: sharedEventEmitter // Optional: share events with other components
});

// Add nodes
dag.addNode({ id: "n1", type: "number" });
dag.addNode({ id: "n2", type: "number" });

// Get edges for a node
const inputEdges = dag.getNodeInputEdges("n2"); // All incoming
const outputEdges = dag.getNodeOutputEdges("n1"); // All outgoing

// Get dependencies
const deps = dag.getNodeDependencies("n2"); // ["n1"]
const dependents = dag.getNodeDependents("n1"); // ["n2"]

// Check BEFORE creating edge
const canConnect = dag.canConnect("n1", "out", "n2", "in");
if (!canConnect) {
  console.log("Structurally impossible!");
}

// Check type compatibility
const validation = dag.validateConnection("n1", "out", "n2", "in");
if (!validation.valid) {
  console.log(`Type mismatch: ${validation.reason}`);
}

// Add edge (works even if invalid!)
dag.addEdge({
  id: "e1",
  source: { nodeId: "n1", socketId: "out" },
  target: { nodeId: "n2", socketId: "in" },
});

// When user drags from output socket
const targets = await dag.findValidTargets("sourceNode", "output", {
  async: true,
  batchSize: 10,
  useCache: true,
});

// Highlight valid targets in UI
targets.forEach((target) => {
  if (target.valid) {
    highlightSocket(target.nodeId, target.socketId, "green");
  }
});

// Get execution order
const order = dag.topologicalSort();
if (!order) {
  console.error("Graph has cycles!");
}

// Find disconnected components
const islands = dag.findIslands();
console.log(`Found ${islands.length} disconnected components`);

// Organize into parallel layers
const layers = dag.organizeLayers();
layers.forEach((layer) => {
  console.log(`Layer ${layer.level}: ${layer.nodes.length} nodes`);
});

// Find hub nodes
const hubs = dag.findHubs();
hubs.forEach((hub) => {
  console.log(`Hub ${hub.node.id}: ${hub.connections} connections`);
});

// Register local type for a group
dag.registerLocal("group:calculator", {
  inputs: [
    { id: "a", schema: { type: "number" } },
    { id: "b", schema: { type: "number" } },
  ],
  outputs: [{ id: "sum", schema: { type: "number" } }],
});

// Use like any other type
dag.addNode({ id: "calc1", type: "group:calculator" });

// List local types
const localTypes = dag.getLocalTypes(); // ["group:calculator"]

// Save graph
const data = dag.serialize();
localStorage.setItem("myGraph", JSON.stringify(data));

// Load graph
const savedData = JSON.parse(localStorage.getItem("myGraph"));
dag.load(savedData);

// Or create new instance
const newDag = DAGGraph.import(savedData);

// Option 1: Use default EventEmitter
const dag = new DAGGraph({ registry });

// Option 2: Share EventEmitter with other components (e.g., Runtime)
const sharedEvents = new EventEmitter<DAGGraphEvents>();
const dag = new DAGGraph({ 
  registry,
  eventEmitter: sharedEvents // Share events across systems
});

// Structure change events (from base Graph)
dag.on("node:added", (node) => console.log(`Node ${node.id} added`));
dag.on("node:removed", (nodeId, node) => console.log(`Node ${nodeId} removed`));
dag.on("edge:added", (edge) => console.log(`Edge ${edge.id} added`));
dag.on("edge:removed", (edgeId, edge) => console.log(`Edge ${edgeId} removed`));

// DAG-specific events
dag.on("dag:cycle:detected", (edge, cyclePath) => {
  console.error(`Cycle detected: ${cyclePath.join(" -> ")}`);
});

dag.on("dag:validation:changed", (edgeId, result) => {
  if (!result.valid) {
    console.warn(`Edge ${edgeId} invalid: ${result.reason}`);
  }
});

dag.on("dag:topology:invalidated", () => {
  console.log("Graph structure changed, recalculating execution order");
});

// Validation lifecycle events
dag.on("dag:graphValidation:started", () => {
  showProgressBar();
});

dag.on("dag:graphValidation:progress", ({ current, total }) => {
  updateProgress(current, total);
});

dag.on("dag:graphValidation:completed", (results) => {
  hideProgressBar();
  const invalid = Array.from(results.values()).filter(r => !r.valid);
  if (invalid.length > 0) {
    console.warn(`${invalid.length} edges have validation issues`);
  }
});

// Batch validation events
dag.on("dag:validation:batch:completed", (results) => {
  console.log(`Batch validation completed for ${results.size} edges`);
});

function createEdgeSafely(dag: DAGGraph, source: any, target: any): boolean {
  const validation = dag.validateConnection(
    source.nodeId,
    source.socketId,
    target.nodeId,
    target.socketId,
  );

  if (!validation.valid) {
    if (validation.severity === "error") {
      alert(`Cannot connect: ${validation.reason}`);
      return false;
    }

    if (validation.severity === "restriction") {
      if (!confirm(`Warning: ${validation.reason}. Continue?`)) {
        return false;
      }
    }
  }

  dag.addEdge({
    id: generateId(),
    source,
    target,
  });

  return true;
}

function executeGraph(dag: DAGGraph) {
  // Get execution order
  const order = dag.topologicalSort();
  if (!order) {
    throw new Error("Graph contains cycles!");
  }

  // Execute layer by layer for parallelization
  const layers = dag.organizeLayers();

  for (const layer of layers) {
    // All nodes in same layer can run in parallel
    await Promise.all(layer.nodes.map((node) => executeNode(node)));
  }
}

// After loading or changes
const invalidEdges = dag.getInvalidEdges();

invalidEdges.forEach((edgeId) => {
  const validation = dag.getEdgeValidation(edgeId);

  const color = validation.severity === "error" ? "red" : "yellow";
  highlightEdge(edgeId, color);

  // Show tooltip on hover
  setEdgeTooltip(edgeId, validation.reason);
});