import { and, eq } from "drizzle-orm";
import { db } from "@/lib/db";
import { canvasProject } from "@/lib/db/schema";
import { resolveCanvasAgentMediaPlacements } from "@/lib/canvas/agent-placement";
import { shouldRejectStaleCanvasAgentHighRiskMutation } from "@/lib/canvas/agent-risk";
import {
  appendCanvasAgentOperationAudit,
  appendCanvasAgentOperationAuditIfMissing,
  buildIdempotentCanvasAgentAuditResult,
  findCanvasAgentOperationAudit,
  normalizeCanvasAgentAuditStringList,
} from "@/lib/canvas/agent-operation-audit";
import { syncCanvasNodeNoteAnnotationMetadata } from "@/lib/canvas/agent-annotation-metadata";
import type {
  CanvasMediaItem,
  CanvasOperationPlan,
} from "@/types/canvas/agent-protocol";

export type CanvasDataLike = {
  nodes?: any[];
  edges?: any[];
  selectedNodeIds?: string[];
  viewport?: { x: number; y: number; zoom: number };
  [key: string]: unknown;
};

export type CanvasOperationResult = {
  createdNodeIds: string[];
  createdNodeIdsByMediaItemId: Record<string, string>;
  updatedNodeIds: string[];
  createdEdgeIds: string[];
  canvasData: CanvasDataLike;
  canvasRevision: string;
  canvasUpdatedAt: string;
  baseCanvasWasStale: boolean;
};

export class CanvasAgentMutationError extends Error {
  status: number;
  code?: string;

  constructor(message: string, status = 400, code?: string) {
    super(message);
    this.name = "CanvasAgentMutationError";
    this.status = status;
    this.code = code;
  }
}

function generateId() {
  return crypto.randomUUID();
}

function normalizeCanvasData(value: unknown): CanvasDataLike {
  if (!value || typeof value !== "object" || Array.isArray(value)) {
    return {
      nodes: [],
      edges: [],
      viewport: { x: 0, y: 0, zoom: 1 },
    };
  }
  const raw = value as CanvasDataLike;
  return {
    ...raw,
    nodes: Array.isArray(raw.nodes) ? [...raw.nodes] : [],
    edges: Array.isArray(raw.edges) ? [...raw.edges] : [],
    selectedNodeIds: Array.isArray(raw.selectedNodeIds)
      ? raw.selectedNodeIds.filter((id): id is string => typeof id === "string")
      : [],
    viewport: raw.viewport || { x: 0, y: 0, zoom: 1 },
  };
}

function normalizeMediaItems(plan: CanvasOperationPlan): CanvasMediaItem[] {
  if (Array.isArray(plan.mediaItems) && plan.mediaItems.length > 0) {
    return plan.mediaItems
      .map((item, index) => ({
        ...item,
        mediaItemId:
          typeof item.mediaItemId === "string" && item.mediaItemId.trim()
            ? item.mediaItemId.trim()
            : `${plan.operationId}:media-${index + 1}`,
        url: typeof item.url === "string" ? item.url.trim() : "",
      }))
      .filter((item) => item.url);
  }

  if (plan.media?.url) {
    return [
      {
        ...plan.media,
        mediaItemId: `${plan.operationId}:media-1`,
        url: plan.media.url.trim(),
      },
    ];
  }

  return [];
}

function findNode(nodes: any[], nodeId?: string) {
  if (!nodeId) return null;
  return nodes.find((node) => node?.id === nodeId) || null;
}

function mediaNodeType(item: CanvasMediaItem) {
  return item.type === "video" ? "video" : "image";
}

function buildMediaNode(params: {
  item: CanvasMediaItem;
  plan: CanvasOperationPlan;
  position: { x: number; y: number };
  size: { width: number; height: number };
  sourceNodeIds: string[];
}) {
  const now = new Date().toISOString();
  const type = mediaNodeType(params.item);
  const itemMetadata =
    params.item.metadata &&
    typeof params.item.metadata === "object" &&
    !Array.isArray(params.item.metadata)
      ? params.item.metadata
      : {};
  const planMetadata =
    params.plan.metadata &&
    typeof params.plan.metadata === "object" &&
    !Array.isArray(params.plan.metadata)
      ? params.plan.metadata
      : {};
  const sourceMessageId = String(
    itemMetadata.messageId || planMetadata.messageId || ""
  ).trim();
  const sourcePrompt = String(
    params.item.prompt || itemMetadata.prompt || planMetadata.prompt || ""
  ).trim();
  const sourceModel = String(itemMetadata.model || planMetadata.model || "").trim();
  const primarySourceNodeId = String(
    itemMetadata.sourceNodeId || planMetadata.sourceNodeId || params.sourceNodeIds[0] || ""
  ).trim();
  const metadata = {
    ...planMetadata,
    ...itemMetadata,
    generatedByAgent: true,
    canvasAgentOperationId: params.plan.operationId,
    canvasAgentOperation: params.plan.operation,
    canvasAgentMediaItemId: params.item.mediaItemId,
    canvasAgentPlacement: params.plan.placement,
    canvasAgentPlacementStrategy: params.plan.placementStrategy,
    messageId: sourceMessageId || undefined,
    prompt: sourcePrompt || undefined,
    model: sourceModel || undefined,
    sourceNodeId: primarySourceNodeId || undefined,
    sourceMessageId: sourceMessageId || undefined,
    sourceImageKey: type === "image" && sourceMessageId ? params.item.url : undefined,
    sourceNodeIds: params.sourceNodeIds,
    revisionOf:
      params.plan.operation === "append_revision"
        ? params.sourceNodeIds[0] || null
        : undefined,
  };

  return {
    id: generateId(),
    type,
    position: params.position,
    size: params.size,
    data:
      type === "video"
        ? {
            src: params.item.url,
            assetId: params.item.assetId,
            status: "completed",
            prompt: params.item.prompt,
            title: params.item.title || "Agent 视频结果",
            metadata,
          }
        : {
            src: params.item.url,
            assetId: params.item.assetId,
            status: "completed",
            prompt: params.item.prompt,
            title: params.item.title || "Agent 图片结果",
            metadata,
          },
    connections: params.sourceNodeIds,
    createdAt: now,
    updatedAt: now,
  };
}

function buildEdge(source: string, target: string, type: "default" | "reference") {
  return {
    id: generateId(),
    source,
    target,
    type,
  };
}

function rebuildConnections(nodes: any[], edges: any[]) {
  const connectionMap = new Map<string, Set<string>>();
  nodes.forEach((node) => connectionMap.set(node.id, new Set()));
  edges.forEach((edge) => {
    connectionMap.get(edge.source)?.add(edge.target);
    connectionMap.get(edge.target)?.add(edge.source);
  });
  nodes.forEach((node) => {
    node.connections = Array.from(connectionMap.get(node.id) || []);
  });
}

function findExistingOperationNodes(nodes: any[], operationId: string) {
  return nodes.filter(
    (node) => node?.data?.metadata?.canvasAgentOperationId === operationId
  );
}

function getPlanBaseTime(plan: CanvasOperationPlan) {
  const raw = String(plan.baseCanvasUpdatedAt || plan.baseCanvasRevision || "").trim();
  if (!raw) return null;
  const parsed = new Date(raw);
  return Number.isNaN(parsed.getTime()) ? null : parsed;
}

function isPlanBaseStale(plan: CanvasOperationPlan, projectUpdatedAt: Date) {
  const baseTime = getPlanBaseTime(plan);
  if (!baseTime) return false;
  return baseTime.getTime() + 1000 < projectUpdatedAt.getTime();
}

function normalizeSlotFillPolicy(value: unknown) {
  return value === "append-version" || value === "replace-existing"
    ? value
    : "replace-empty";
}

function normalizeAgentSlotType(value: unknown): "image" | "video" | "ui-screen" {
  return value === "video" || value === "ui-screen" ? value : "image";
}

function normalizeAgentSlotAcceptedSources(value: unknown) {
  const allowed = new Set(["text", "image", "selection", "annotation"]);
  const sources = Array.isArray(value)
    ? value
        .map((item) => String(item || "").trim())
        .filter((item) => allowed.has(item))
    : [];
  return sources.length > 0
    ? Array.from(new Set(sources))
    : ["text", "image", "selection", "annotation"];
}

function getAgentSlotDefaults(slotType: "image" | "video" | "ui-screen") {
  if (slotType === "video") {
    return {
      label: "视频槽位",
      aspectRatio: "16:9",
      size: { width: 360, height: 220 },
    };
  }
  if (slotType === "ui-screen") {
    return {
      label: "UI 槽位",
      aspectRatio: "16:9",
      size: { width: 360, height: 260 },
    };
  }
  return {
    label: "图片槽位",
    aspectRatio: "1:1",
    size: { width: 320, height: 320 },
  };
}

function isMediaItemCompatibleWithAgentSlot(params: {
  slotType: "image" | "video" | "ui-screen";
  mediaType: CanvasMediaItem["type"];
}) {
  if (params.slotType === "video") return params.mediaType === "video";
  return params.mediaType === "image";
}

function assertMediaItemsCompatibleWithAgentSlot(params: {
  targetSlot: any;
  mediaItems: CanvasMediaItem[];
}) {
  const targetSlotData = (params.targetSlot?.data || {}) as Record<string, unknown>;
  const slotType = normalizeAgentSlotType(targetSlotData.slotType);
  const mismatchedItem = params.mediaItems.find(
    (item) =>
      !isMediaItemCompatibleWithAgentSlot({
        slotType,
        mediaType: item.type,
      })
  );
  if (!mismatchedItem) return;

  const expectedLabel = slotType === "video" ? "视频" : "图片";
  const actualLabel = mismatchedItem.type === "video" ? "视频" : "图片";
  throw new CanvasAgentMutationError(
    `目标 slot 是${expectedLabel}槽位，不能填充${actualLabel}结果`,
    400,
    "CANVAS_AGENT_SLOT_MEDIA_TYPE_MISMATCH"
  );
}

function getCanvasViewportCenterPosition(params: {
  canvasData: CanvasDataLike;
  size: { width: number; height: number };
}) {
  const viewport = params.canvasData.viewport || { x: 0, y: 0, zoom: 1 };
  const zoom = Math.max(0.1, Number(viewport.zoom || 1));
  const viewportWidth = Math.max(320, Number((viewport as any).width || 1200));
  const viewportHeight = Math.max(320, Number((viewport as any).height || 800));
  return {
    x: (viewportWidth / 2 - Number(viewport.x || 0)) / zoom - params.size.width / 2,
    y: (viewportHeight / 2 - Number(viewport.y || 0)) / zoom - params.size.height / 2,
  };
}

function normalizeEdgeType(value: unknown): "default" | "reference" | "conversation" {
  return value === "default" || value === "conversation" ? value : "reference";
}

function normalizeAnnotationType(
  value: unknown
): "text-note" | "arrow-note" | "box" | "freehand" | "crop-box" {
  return value === "arrow-note" ||
    value === "box" ||
    value === "freehand" ||
    value === "crop-box"
    ? value
    : "text-note";
}

function normalizeAnnotationPoint(value: unknown) {
  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
  const raw = value as Record<string, unknown>;
  const x = Number(raw.x);
  const y = Number(raw.y);
  if (!Number.isFinite(x) || !Number.isFinite(y)) return undefined;
  return { x, y };
}

function normalizeAnnotationBounds(value: unknown) {
  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
  const raw = value as Record<string, unknown>;
  const x = Number(raw.x);
  const y = Number(raw.y);
  const width = Number(raw.width);
  const height = Number(raw.height);
  if (
    !Number.isFinite(x) ||
    !Number.isFinite(y) ||
    !Number.isFinite(width) ||
    !Number.isFinite(height)
  ) {
    return undefined;
  }
  return {
    x,
    y,
    width: Math.max(0, width),
    height: Math.max(0, height),
  };
}

function edgeMatches(edge: any, source: string, target: string) {
  return (
    (edge?.source === source && edge?.target === target) ||
    (edge?.source === target && edge?.target === source)
  );
}

function getOperationTargetNodeIds(plan: CanvasOperationPlan) {
  return Array.from(
    new Set(
      [
        plan.anchorNodeId || "",
        ...(plan.targetNodeIds || []),
        ...(plan.sourceNodeIds || []),
      ].filter(Boolean)
    )
  );
}

function assertCanvasAgentReferencedNodesExist(params: {
  nodes: any[];
  plan: CanvasOperationPlan;
  mediaItems?: CanvasMediaItem[];
}) {
  if (params.plan.anchorNodeId && !findNode(params.nodes, params.plan.anchorNodeId)) {
    throw new CanvasAgentMutationError(
      `锚点节点不存在：${params.plan.anchorNodeId}`
    );
  }

  const missingSourceNodeId = (params.plan.sourceNodeIds || []).find(
    (nodeId) => !findNode(params.nodes, nodeId)
  );
  if (missingSourceNodeId) {
    throw new CanvasAgentMutationError(`来源节点不存在：${missingSourceNodeId}`);
  }

  const missingMediaSourceNodeId = (params.mediaItems || [])
    .flatMap((item) => item.sourceNodeIds || [])
    .find((nodeId) => !findNode(params.nodes, nodeId));
  if (missingMediaSourceNodeId) {
    throw new CanvasAgentMutationError(
      `媒体来源节点不存在：${missingMediaSourceNodeId}`
    );
  }
}

function normalizeCanvasMetadata(value: unknown) {
  return value && typeof value === "object" && !Array.isArray(value)
    ? { ...(value as Record<string, unknown>) }
    : {};
}

function getNodeSize(node: any) {
  return {
    width: Math.max(1, Number(node?.size?.width || 220) || 220),
    height: Math.max(1, Number(node?.size?.height || 160) || 160),
  };
}

function getNodePosition(node: any) {
  return {
    x: Number(node?.position?.x || 0) || 0,
    y: Number(node?.position?.y || 0) || 0,
  };
}

function removeCanvasNodesAndConnectedEdges(params: {
  nodes: any[];
  edges: any[];
  nodeIds: string[];
}) {
  const deleteSet = new Set(params.nodeIds.filter(Boolean));
  if (deleteSet.size === 0) return [];

  const removedNodeIds = params.nodes
    .filter((node) => deleteSet.has(node?.id))
    .map((node) => node.id);
  if (removedNodeIds.length === 0) return [];

  for (let index = params.nodes.length - 1; index >= 0; index -= 1) {
    if (deleteSet.has(params.nodes[index]?.id)) {
      params.nodes.splice(index, 1);
    }
  }
  for (let index = params.edges.length - 1; index >= 0; index -= 1) {
    const edge = params.edges[index];
    if (deleteSet.has(edge?.source) || deleteSet.has(edge?.target)) {
      params.edges.splice(index, 1);
    }
  }

  return removedNodeIds;
}

function isConfirmedHighRiskPlan(plan: CanvasOperationPlan) {
  const metadata = (plan.metadata || {}) as Record<string, unknown>;
  return plan.confirmed === true || metadata.confirmedByUser === true;
}

function assertFreshBaseForCanvasAgentHighRiskMutation(
  plan: CanvasOperationPlan,
  baseCanvasWasStale?: boolean
) {
  if (
    shouldRejectStaleCanvasAgentHighRiskMutation({
      operation: plan.operation,
      confirmed: plan.confirmed,
      metadata: plan.metadata,
      baseCanvasWasStale,
    })
  ) {
    throw new CanvasAgentMutationError(
      "画布已更新，高风险操作需要刷新后重新确认",
      409,
      "STALE_CANVAS_REVISION"
    );
  }
}

function normalizeLayoutStrategy(value: unknown): "row" | "column" | "grid" {
  return value === "column" || value === "grid" ? value : "row";
}

function resolveMoveStartPosition(nodes: any[], plan: CanvasOperationPlan) {
  const target = plan.targetPosition;
  if (
    target &&
    Number.isFinite(Number(target.x)) &&
    Number.isFinite(Number(target.y))
  ) {
    return {
      x: Number(target.x),
      y: Number(target.y),
    };
  }

  const positions = nodes.map(getNodePosition);
  return {
    x: Math.min(...positions.map((position) => position.x)),
    y: Math.min(...positions.map((position) => position.y)),
  };
}

function applyMoveNodesOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  if (!isConfirmedHighRiskPlan(params.plan)) {
    throw new CanvasAgentMutationError(
      "移动画布节点需要用户确认",
      409,
      "CANVAS_AGENT_CONFIRMATION_REQUIRED"
    );
  }

  const targetNodeIds = getOperationTargetNodeIds(params.plan);
  if (targetNodeIds.length === 0) {
    throw new CanvasAgentMutationError("缺少要移动的节点");
  }

  const targetNodes = targetNodeIds.map((nodeId) => findNode(params.nodes, nodeId));
  const missingIndex = targetNodes.findIndex((node) => !node);
  if (missingIndex >= 0) {
    throw new CanvasAgentMutationError(`移动节点不存在：${targetNodeIds[missingIndex]}`);
  }

  const orderedNodes = (targetNodes as any[]).sort((a, b) => {
    const posA = getNodePosition(a);
    const posB = getNodePosition(b);
    return posA.y === posB.y ? posA.x - posB.x : posA.y - posB.y;
  });
  const spacing = Math.max(8, Math.min(240, Number(params.plan.spacing || 40) || 40));
  const layoutStrategy = normalizeLayoutStrategy(params.plan.layoutStrategy);
  const start = resolveMoveStartPosition(orderedNodes, params.plan);
  const sizes = orderedNodes.map(getNodeSize);
  const maxWidth = Math.max(...sizes.map((size) => size.width));
  const maxHeight = Math.max(...sizes.map((size) => size.height));
  const now = new Date().toISOString();

  orderedNodes.forEach((node, index) => {
    let position = { x: start.x, y: start.y };
    if (layoutStrategy === "column") {
      const previousHeights = sizes
        .slice(0, index)
        .reduce((sum, size) => sum + size.height + spacing, 0);
      position = { x: start.x, y: start.y + previousHeights };
    } else if (layoutStrategy === "grid") {
      const cols = Math.max(1, Math.ceil(Math.sqrt(orderedNodes.length)));
      const col = index % cols;
      const row = Math.floor(index / cols);
      position = {
        x: start.x + col * (maxWidth + spacing),
        y: start.y + row * (maxHeight + spacing),
      };
    } else {
      const previousWidths = sizes
        .slice(0, index)
        .reduce((sum, size) => sum + size.width + spacing, 0);
      position = { x: start.x + previousWidths, y: start.y };
    }

    const previousPosition = getNodePosition(node);
    const data = (node.data || {}) as Record<string, any>;
    node.position = position;
    node.data = {
      ...data,
      metadata: {
        ...(data.metadata || {}),
        movedByAgent: true,
        canvasAgentOperationId: params.plan.operationId,
        canvasAgentOperation: params.plan.operation,
        canvasAgentLayoutStrategy: layoutStrategy,
        previousPosition,
        agentMovedAt: now,
      },
    };
    node.updatedAt = now;
  });

  return {
    canvasData: {
      ...params.canvasData,
      nodes: params.nodes,
      edges: params.edges,
      selectedNodeIds: orderedNodes.map((node) => node.id),
    },
    createdNodeIds: [],
    createdNodeIdsByMediaItemId: {},
    updatedNodeIds: orderedNodes.map((node) => node.id),
    createdEdgeIds: [],
  };
}

function getNodeMediaSnapshot(node: any) {
  const data = (node?.data || {}) as Record<string, any>;
  return {
    type: node?.type,
    src: typeof data.src === "string" ? data.src : "",
    assetId: typeof data.assetId === "string" ? data.assetId : undefined,
    title: typeof data.title === "string" ? data.title : undefined,
    prompt: typeof data.prompt === "string" ? data.prompt : undefined,
    status: typeof data.status === "string" ? data.status : undefined,
  };
}

function getReplacementMediaItemsForTargets(params: {
  mediaItems: CanvasMediaItem[];
  targetNodeIds: string[];
}) {
  if (params.mediaItems.length === params.targetNodeIds.length) {
    return params.targetNodeIds.map((targetNodeId, index) => {
      const explicit = params.mediaItems.find((item) =>
        Array.isArray(item.sourceNodeIds)
          ? item.sourceNodeIds.includes(targetNodeId)
          : false
      );
      return explicit || params.mediaItems[index];
    });
  }

  if (params.mediaItems.length === 1 && params.targetNodeIds.length === 1) {
    return params.mediaItems;
  }

  throw new CanvasAgentMutationError("替换媒体数量必须与目标节点数量一致");
}

function applyReplaceNodeMediaOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  if (!isConfirmedHighRiskPlan(params.plan)) {
    throw new CanvasAgentMutationError(
      "替换画布媒体需要用户确认",
      409,
      "CANVAS_AGENT_CONFIRMATION_REQUIRED"
    );
  }

  const targetNodeIds = getOperationTargetNodeIds(params.plan);
  if (targetNodeIds.length === 0) {
    throw new CanvasAgentMutationError("缺少要替换的媒体节点");
  }

  const mediaItems = normalizeMediaItems(params.plan);
  if (mediaItems.length === 0) {
    throw new CanvasAgentMutationError("缺少替换媒体结果");
  }

  const replacementItems = getReplacementMediaItemsForTargets({
    mediaItems,
    targetNodeIds,
  });
  const now = new Date().toISOString();
  const createdNodeIdsByMediaItemId: Record<string, string> = {};
  const updatedNodeIds: string[] = [];

  targetNodeIds.forEach((nodeId, index) => {
    const node = findNode(params.nodes, nodeId);
    if (!node) {
      throw new CanvasAgentMutationError(`替换节点不存在：${nodeId}`);
    }
    if (node.type !== "image" && node.type !== "video") {
      throw new CanvasAgentMutationError("replace_node_media 只能替换图片或视频节点");
    }

    const item = replacementItems[index];
    if (!item) {
      throw new CanvasAgentMutationError("缺少替换媒体结果");
    }
    if (item.type !== node.type) {
      throw new CanvasAgentMutationError("替换媒体类型必须与目标节点类型一致");
    }

    const data = (node.data || {}) as Record<string, any>;
    const previousMedia = getNodeMediaSnapshot(node);
    node.data = {
      ...data,
      src: item.url,
      assetId: item.assetId || data.assetId,
      status: "completed",
      prompt: item.prompt || data.prompt,
      title: item.title || data.title,
      metadata: {
        ...(data.metadata || {}),
        ...(item.metadata || {}),
        replacedByAgent: true,
        canvasAgentOperationId: params.plan.operationId,
        canvasAgentOperation: params.plan.operation,
        canvasAgentMediaItemId: item.mediaItemId,
        previousMedia,
        agentReplacedAt: now,
      },
    };
    node.updatedAt = now;
    updatedNodeIds.push(node.id);
    createdNodeIdsByMediaItemId[item.mediaItemId] = node.id;
  });

  rebuildConnections(params.nodes, params.edges);

  return {
    canvasData: {
      ...params.canvasData,
      nodes: params.nodes,
      edges: params.edges,
      selectedNodeIds: updatedNodeIds,
    },
    createdNodeIds: [],
    createdNodeIdsByMediaItemId,
    updatedNodeIds,
    createdEdgeIds: [],
  };
}

function applyDeleteNodesOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  if (!isConfirmedHighRiskPlan(params.plan)) {
    throw new CanvasAgentMutationError(
      "删除画布节点需要用户确认",
      409,
      "CANVAS_AGENT_CONFIRMATION_REQUIRED"
    );
  }

  const targetNodeIds = getOperationTargetNodeIds(params.plan);
  if (targetNodeIds.length === 0) {
    throw new CanvasAgentMutationError("缺少要删除的节点");
  }

  const targetNodes = targetNodeIds.map((nodeId) => findNode(params.nodes, nodeId));
  const missingIndex = targetNodes.findIndex((node) => !node);
  if (missingIndex >= 0) {
    throw new CanvasAgentMutationError(`删除节点不存在：${targetNodeIds[missingIndex]}`);
  }
  if (targetNodes.some((node) => node?.type === "agent-slot")) {
    throw new CanvasAgentMutationError("Agent slot 默认不允许删除，请手动处理 slot");
  }

  const targetSet = new Set(targetNodeIds);
  const deletedNodes = targetNodes.map((node) => JSON.parse(JSON.stringify(node)));
  const deletedEdges = params.edges
    .filter((edge) => targetSet.has(edge.source) || targetSet.has(edge.target))
    .map((edge) => JSON.parse(JSON.stringify(edge)));
  const remainingNodes = params.nodes.filter((node) => !targetSet.has(node.id));
  const remainingEdges = params.edges.filter(
    (edge) => !targetSet.has(edge.source) && !targetSet.has(edge.target)
  );
  rebuildConnections(remainingNodes, remainingEdges);

  const auditedCanvasData = appendCanvasAgentOperationAudit({
    canvasData: params.canvasData,
    auditEntry: {
      operationId: params.plan.operationId,
      operation: params.plan.operation,
      targetNodeIds,
      deletedNodeIds: targetNodeIds,
      deletedNodes,
      deletedEdges,
      deletedAt: new Date().toISOString(),
      metadata: params.plan.metadata || {},
    },
  });

  return {
    canvasData: {
      ...auditedCanvasData,
      nodes: remainingNodes,
      edges: remainingEdges,
      selectedNodeIds: [],
    },
    createdNodeIds: [],
    createdNodeIdsByMediaItemId: {},
    updatedNodeIds: targetNodeIds,
    createdEdgeIds: [],
  };
}

function normalizePlanAnnotations(plan: CanvasOperationPlan, fallbackText: string) {
  const rawAnnotations = Array.isArray(plan.annotations) ? plan.annotations : [];
  const normalized = rawAnnotations
    .map((annotation) => {
      if (!annotation || typeof annotation !== "object") return null;
      const raw = annotation as Record<string, unknown>;
      const text =
        typeof raw.text === "string"
          ? String(raw.text).trim().slice(0, 1000)
          : undefined;
      return {
        id: typeof raw.id === "string" ? String(raw.id).trim().slice(0, 128) : "",
        sourceNodeId:
          typeof raw.sourceNodeId === "string"
            ? String(raw.sourceNodeId).trim().slice(0, 128)
            : "",
        type: normalizeAnnotationType(raw.type),
        text,
        bounds: normalizeAnnotationBounds(raw.bounds),
        targetPoint: normalizeAnnotationPoint(raw.targetPoint),
        color:
          typeof raw.color === "string" ? String(raw.color).trim().slice(0, 64) : undefined,
        createdAt:
          typeof raw.createdAt === "string"
            ? String(raw.createdAt).trim().slice(0, 64)
            : undefined,
      };
    })
    .filter((annotation): annotation is NonNullable<typeof annotation> =>
      Boolean(annotation)
    );

  if (normalized.length > 0) return normalized.slice(0, 20);
  if (!fallbackText) return [];
  return [
    {
      id: "",
      sourceNodeId: "",
      type: "text-note" as const,
      text: fallbackText.slice(0, 1000),
      bounds: undefined,
      targetPoint: undefined,
      color: undefined,
      createdAt: undefined,
    },
  ];
}

function applyAddAnnotationOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  const targetNodeIds = getOperationTargetNodeIds(params.plan);
  if (targetNodeIds.length === 0) {
    throw new CanvasAgentMutationError("缺少要添加批注的节点");
  }

  const fallbackText = String(params.plan.textContent || "").trim();
  const annotations = normalizePlanAnnotations(params.plan, fallbackText);
  if (annotations.length === 0) {
    throw new CanvasAgentMutationError("缺少批注内容");
  }

  const now = new Date().toISOString();
  const updatedNodeIds: string[] = [];

  targetNodeIds.forEach((nodeId) => {
    const node = findNode(params.nodes, nodeId);
    if (!node) {
      throw new CanvasAgentMutationError(`批注节点不存在：${nodeId}`);
    }
    if (node.type !== "image" && node.type !== "video") {
      throw new CanvasAgentMutationError("add_annotation 只能给图片或视频节点添加批注");
    }

    const data = (node.data || {}) as Record<string, any>;
    const metadata = normalizeCanvasMetadata(data.metadata);
    const existingAnnotations = Array.isArray(metadata.annotations)
      ? metadata.annotations.filter((item) => item && typeof item === "object")
      : [];
    const hasExistingOperationAnnotation = existingAnnotations.some(
      (item) =>
        (item as Record<string, unknown>).canvasAgentOperationId ===
        params.plan.operationId
    );
    if (hasExistingOperationAnnotation) return;

    const nextAnnotations = annotations.map((annotation, index) => ({
      ...annotation,
      id:
        annotation.id ||
        `${params.plan.operationId}:annotation-${node.id}-${index + 1}`,
      sourceNodeId: annotation.sourceNodeId || node.id,
      createdAt: annotation.createdAt || now,
      createdByAgent: true,
      canvasAgentOperationId: params.plan.operationId,
    }));

    node.data = {
      ...data,
      hasAnnotations: true,
      metadata: {
        ...metadata,
        annotations: [...existingAnnotations, ...nextAnnotations].slice(-50),
        annotationsUpdatedAt: now,
      },
    };
    node.updatedAt = now;
    updatedNodeIds.push(node.id);
  });

  return {
    canvasData: {
      ...params.canvasData,
      nodes: params.nodes,
      edges: params.edges,
      selectedNodeIds: updatedNodeIds,
    },
    createdNodeIds: [],
    createdNodeIdsByMediaItemId: {},
    updatedNodeIds,
    createdEdgeIds: [],
  };
}

function applyCreateAgentSlotOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  const now = new Date().toISOString();
  const slotMetadata = (params.plan.metadata || {}) as Record<string, unknown>;
  const slotSpec = (params.plan.slot || {}) as Record<string, unknown>;
  const slotType = normalizeAgentSlotType(slotSpec.slotType || slotMetadata.slotType);
  const defaults = getAgentSlotDefaults(slotType);
  const label = String(slotSpec.label || defaults.label).trim().slice(0, 120);
  const aspectRatio = String(slotSpec.aspectRatio || defaults.aspectRatio)
    .trim()
    .slice(0, 32);
  const fillPolicy = normalizeSlotFillPolicy(slotSpec.fillPolicy);
  const acceptedSources = normalizeAgentSlotAcceptedSources(slotSpec.acceptedSources);
  const targetPosition =
    params.plan.targetPosition &&
    Number.isFinite(Number(params.plan.targetPosition.x)) &&
    Number.isFinite(Number(params.plan.targetPosition.y))
      ? {
          x: Number(params.plan.targetPosition.x),
          y: Number(params.plan.targetPosition.y),
        }
      : getCanvasViewportCenterPosition({
          canvasData: params.canvasData,
          size: defaults.size,
        });

  const node = {
    id: generateId(),
    type: "agent-slot",
    position: targetPosition,
    size: defaults.size,
    data: {
      slotType,
      label,
      status: "empty",
      aspectRatio,
      fillPolicy,
      acceptedSources,
      filledNodeIds: [],
      metadata: {
        ...(params.plan.metadata || {}),
        createdByAgent: true,
        canvasAgentOperationId: params.plan.operationId,
        canvasAgentOperation: params.plan.operation,
        agentCreatedAt: now,
      },
    },
    connections: [],
    createdAt: now,
    updatedAt: now,
  };

  params.nodes.push(node);

  return {
    canvasData: {
      ...params.canvasData,
      nodes: params.nodes,
      edges: params.edges,
      selectedNodeIds: [node.id],
    },
    createdNodeIds: [node.id],
    createdNodeIdsByMediaItemId: {},
    updatedNodeIds: [],
    createdEdgeIds: [],
  };
}

function getTextNodeSize(textContent: string) {
  const lines = textContent.split(/\r?\n/);
  const longestLineLength = Math.max(
    1,
    ...lines.map((line) => Array.from(line).length)
  );
  return {
    width: Math.min(520, Math.max(260, longestLineLength * 10 + 48)),
    height: Math.min(280, Math.max(96, lines.length * 30 + 56)),
  };
}

function applyCreateTextNodeOperation(params: {
  canvasData: CanvasDataLike;
  nodes: any[];
  edges: any[];
  plan: CanvasOperationPlan;
}) {
  const textContent = String(params.plan.textContent || "").trim().slice(0, 4000);
  if (!textContent) {
    throw new CanvasAgentMutationError("缺少文本内容");
  }

  const now = new Date().toISOString();
  const size = getTextNodeSize(textContent);
  const targetPosition =
    params.plan.targetPosition &&
    Number.isFinite(Number(params.plan.targetPosition.x)) &&
    Number.isFinite(Number(params.plan.targetPosition.y))
      ? {
          x: Number(params.plan.targetPosition.x),
          y: Number(params.plan.targetPosition.y),
        }
      : getCanvasViewportCenterPosition({
          canvasData: params.canvasData,
          size,
        });
  const node = {
    id: generateId(),
    type: "text",
    position: targetPosition,
    size,
    data: {
      content: textContent,
      fontSize: 18,
      color: "#111827",
      lineHeight: 1.4,
      metadata: {
        ...(params.plan.metadata || {}),
        createdByAgent: true,
        canvasAgentOperationId: params.plan.operationId,
        canvasAgentOperation: params.plan.operation,
        agentCreatedAt: now,
      },
    },
    connections: [],
    createdAt: now,
    updatedAt: now,
  };

  params.nodes.push(node);

  return {
    canvasData: {
      ...params.canvasData,
      nodes: params.nodes,
      edges: params.edges,
      selectedNodeIds: [node.id],
    },
    createdNodeIds: [node.id],
    createdNodeIdsByMediaItemId: {},
    updatedNodeIds: [],
    createdEdgeIds: [],
  };
}

function applyOperationToCanvasData(params: {
  canvasData: CanvasDataLike;
  plan: CanvasOperationPlan;
  baseCanvasWasStale?: boolean;
}) {
  if (!params.plan.operationId) {
    throw new CanvasAgentMutationError("缺少 operationId");
  }
  if (
    params.plan.operation !== "create_agent_slot" &&
    params.plan.operation !== "create_text_node" &&
    params.plan.operation !== "insert_beside" &&
    params.plan.operation !== "append_revision" &&
    params.plan.operation !== "fill_slot" &&
    params.plan.operation !== "link_nodes" &&
    params.plan.operation !== "add_annotation" &&
    params.plan.operation !== "move_nodes" &&
    params.plan.operation !== "replace_node_media" &&
    params.plan.operation !== "delete_nodes" &&
    params.plan.operation !== "rename_node" &&
    params.plan.operation !== "update_note" &&
    params.plan.operation !== "update_text"
  ) {
    throw new CanvasAgentMutationError("当前仅支持非破坏式画布写回操作");
  }

  const nodes = [...(params.canvasData.nodes || [])];
  const edges = [...(params.canvasData.edges || [])];
  const existingOperationNodes = findExistingOperationNodes(
    nodes,
    params.plan.operationId
  );
  const existingAudit = findCanvasAgentOperationAudit(
    params.canvasData,
    params.plan.operationId
  );
  if (existingAudit) {
    const auditResult = buildIdempotentCanvasAgentAuditResult({
      canvasData: params.canvasData,
      audit: existingAudit,
    });
    if (params.plan.operation !== "delete_nodes") {
      return auditResult;
    }
    const deletedNodeIds = normalizeCanvasAgentAuditStringList(
      existingAudit.deletedNodeIds
    );
    return {
      canvasData: params.canvasData,
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds: deletedNodeIds.length > 0 ? deletedNodeIds : auditResult.updatedNodeIds,
      createdEdgeIds: [],
    };
  }

  assertFreshBaseForCanvasAgentHighRiskMutation(
    params.plan,
    params.baseCanvasWasStale
  );

  if (
    existingOperationNodes.length > 0 &&
    (params.plan.operation === "replace_node_media" ||
      params.plan.operation === "move_nodes" ||
      params.plan.operation === "rename_node" ||
      params.plan.operation === "update_note" ||
      params.plan.operation === "update_text")
  ) {
    return {
      canvasData: params.canvasData,
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds: existingOperationNodes.map((node) => node.id),
      createdEdgeIds: [],
    };
  }

  if (params.plan.operation === "delete_nodes") {
    return applyDeleteNodesOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "add_annotation") {
    return applyAddAnnotationOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "replace_node_media") {
    return applyReplaceNodeMediaOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "move_nodes") {
    return applyMoveNodesOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "create_agent_slot") {
    if (existingOperationNodes.length > 0) {
      return {
        canvasData: params.canvasData,
        createdNodeIds: existingOperationNodes.map((node) => node.id),
        createdNodeIdsByMediaItemId: {},
        updatedNodeIds: [],
        createdEdgeIds: [],
      };
    }

    return applyCreateAgentSlotOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "create_text_node") {
    if (existingOperationNodes.length > 0) {
      return {
        canvasData: params.canvasData,
        createdNodeIds: existingOperationNodes.map((node) => node.id),
        createdNodeIdsByMediaItemId: {},
        updatedNodeIds: [],
        createdEdgeIds: [],
      };
    }

    return applyCreateTextNodeOperation({
      canvasData: params.canvasData,
      nodes,
      edges,
      plan: params.plan,
    });
  }

  if (params.plan.operation === "rename_node") {
    const nextTitle = String(params.plan.textContent || "").trim().slice(0, 120);
    if (!nextTitle) {
      throw new CanvasAgentMutationError("缺少节点标题");
    }

    const targetNodeIds = getOperationTargetNodeIds(params.plan);
    if (targetNodeIds.length === 0) {
      throw new CanvasAgentMutationError("缺少要改名的节点");
    }

    const now = new Date().toISOString();
    const updatedNodeIds: string[] = [];
    targetNodeIds.forEach((nodeId) => {
      const node = findNode(nodes, nodeId);
      if (!node) {
        throw new CanvasAgentMutationError(`改名节点不存在：${nodeId}`);
      }

      const data = (node.data || {}) as Record<string, any>;
      const previousTitle =
        typeof data.title === "string"
          ? data.title
          : typeof data.label === "string"
            ? data.label
            : undefined;
      node.data = {
        ...data,
        title: nextTitle,
        label: node.type === "agent-slot" ? nextTitle : data.label,
        metadata: {
          ...(data.metadata || {}),
          renamedByAgent: true,
          canvasAgentOperationId: params.plan.operationId,
          canvasAgentOperation: params.plan.operation,
          previousTitle,
          agentRenamedAt: now,
        },
      };
      node.updatedAt = now;
      updatedNodeIds.push(node.id);
    });

    return {
      canvasData: {
        ...params.canvasData,
        nodes,
        edges,
        selectedNodeIds: updatedNodeIds,
      },
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds,
      createdEdgeIds: [],
    };
  }

  if (params.plan.operation === "update_note") {
    const note = String(params.plan.textContent || "").trim().slice(0, 1000);
    if (!note) {
      throw new CanvasAgentMutationError("缺少备注内容");
    }

    const targetNodeIds = getOperationTargetNodeIds(params.plan);
    if (targetNodeIds.length === 0) {
      throw new CanvasAgentMutationError("缺少要更新备注的节点");
    }

    const now = new Date().toISOString();
    const updatedNodeIds: string[] = [];
    targetNodeIds.forEach((nodeId) => {
      const node = findNode(nodes, nodeId);
      if (!node) {
        throw new CanvasAgentMutationError(`备注节点不存在：${nodeId}`);
      }
      if (node.type !== "image" && node.type !== "video") {
        throw new CanvasAgentMutationError("update_note 只能更新图片或视频节点备注");
      }

      const data = (node.data || {}) as Record<string, any>;
      const previousNote =
        typeof data.note === "string" ? String(data.note).slice(0, 1000) : undefined;
      const noteSync = syncCanvasNodeNoteAnnotationMetadata({
        metadata: data.metadata,
        nodeId: node.id,
        note,
        now,
      });
      const syncedMetadata = normalizeCanvasMetadata(noteSync.metadata);
      const annotations = Array.isArray(syncedMetadata.annotations)
        ? syncedMetadata.annotations.map((annotation) => {
            if (
              annotation &&
              typeof annotation === "object" &&
              (annotation as Record<string, unknown>).id === noteSync.noteAnnotationId
            ) {
              return {
                ...(annotation as Record<string, unknown>),
                createdByAgent: true,
                updatedByAgent: true,
                canvasAgentOperationId: params.plan.operationId,
              };
            }
            return annotation;
          })
        : [];

      node.data = {
        ...data,
        note,
        hasAnnotations: noteSync.hasStructuredAnnotations || data.hasAnnotations,
        metadata: {
          ...syncedMetadata,
          ...(params.plan.metadata || {}),
          annotations,
          noteUpdatedByAgent: true,
          canvasAgentOperationId: params.plan.operationId,
          canvasAgentOperation: params.plan.operation,
          previousNote,
          agentNoteUpdatedAt: now,
        },
      };
      node.updatedAt = now;
      updatedNodeIds.push(node.id);
    });

    return {
      canvasData: {
        ...params.canvasData,
        nodes,
        edges,
        selectedNodeIds: updatedNodeIds,
      },
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds,
      createdEdgeIds: [],
    };
  }

  if (params.plan.operation === "update_text") {
    const textContent = String(params.plan.textContent || "").trim();
    if (!textContent) {
      throw new CanvasAgentMutationError("缺少文本内容");
    }

    const targetNodeIds = getOperationTargetNodeIds(params.plan);
    if (targetNodeIds.length === 0) {
      throw new CanvasAgentMutationError("缺少要更新的文本节点");
    }

    const now = new Date().toISOString();
    const updatedNodeIds: string[] = [];
    targetNodeIds.forEach((nodeId) => {
      const node = findNode(nodes, nodeId);
      if (!node) {
        throw new CanvasAgentMutationError(`文本节点不存在：${nodeId}`);
      }
      if (node.type !== "text") {
        throw new CanvasAgentMutationError("update_text 只能修改文本节点");
      }

      const data = (node.data || {}) as Record<string, any>;
      node.data = {
        ...data,
        content: textContent,
        metadata: {
          ...(data.metadata || {}),
          ...(params.plan.metadata || {}),
          updatedByAgent: true,
          canvasAgentOperationId: params.plan.operationId,
          canvasAgentOperation: params.plan.operation,
          previousContent:
            typeof data.content === "string" ? String(data.content).slice(0, 2000) : undefined,
          agentUpdatedAt: now,
        },
      };
      node.updatedAt = now;
      updatedNodeIds.push(node.id);
    });

    return {
      canvasData: {
        ...params.canvasData,
        nodes,
        edges,
        selectedNodeIds: updatedNodeIds,
      },
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds,
      createdEdgeIds: [],
    };
  }

  if (params.plan.operation === "link_nodes") {
    const nodeIds = getOperationTargetNodeIds(params.plan);
    if (nodeIds.length < 2) {
      throw new CanvasAgentMutationError("连线操作至少需要两个节点");
    }
    const missingNodeId = nodeIds.find((nodeId) => !findNode(nodes, nodeId));
    if (missingNodeId) {
      throw new CanvasAgentMutationError(`连线节点不存在：${missingNodeId}`);
    }

    const edgeType = normalizeEdgeType(params.plan.edgeType);
    const [sourceNodeId, ...targetNodeIds] = nodeIds;
    const createdEdgeIds: string[] = [];
    targetNodeIds.forEach((targetNodeId) => {
      const exists = edges.some((edge) => edgeMatches(edge, sourceNodeId, targetNodeId));
      if (exists) return;
      const edge = {
        id: generateId(),
        source: sourceNodeId,
        target: targetNodeId,
        type: edgeType,
      };
      edges.push(edge);
      createdEdgeIds.push(edge.id);
    });
    rebuildConnections(nodes, edges);

    return {
      canvasData: {
        ...params.canvasData,
        nodes,
        edges,
        selectedNodeIds: nodeIds,
      },
      createdNodeIds: [],
      createdNodeIdsByMediaItemId: {},
      updatedNodeIds: nodeIds,
      createdEdgeIds,
    };
  }

  if (existingOperationNodes.length > 0) {
    const byMediaItemId: Record<string, string> = {};
    existingOperationNodes.forEach((node) => {
      const mediaItemId = String(
        node?.data?.metadata?.canvasAgentMediaItemId || ""
      ).trim();
      if (mediaItemId) byMediaItemId[mediaItemId] = node.id;
    });
    return {
      canvasData: params.canvasData,
      createdNodeIds: existingOperationNodes.map((node) => node.id),
      createdNodeIdsByMediaItemId: byMediaItemId,
      updatedNodeIds: [],
      createdEdgeIds: [],
    };
  }

  const mediaItems = normalizeMediaItems(params.plan);
  if (mediaItems.length === 0) {
    throw new CanvasAgentMutationError("缺少可写回的媒体结果");
  }
  assertCanvasAgentReferencedNodesExist({
    nodes,
    plan: params.plan,
    mediaItems,
  });

  const targetSlot =
    params.plan.operation === "fill_slot"
      ? findNode(nodes, params.plan.targetSlotId)
      : null;
  if (params.plan.operation === "fill_slot" && !targetSlot) {
    throw new CanvasAgentMutationError("目标 slot 不存在");
  }
  let replacedSlotNodeIds: string[] = [];
  if (targetSlot && params.plan.operation === "fill_slot") {
    const targetSlotData = (targetSlot.data || {}) as Record<string, unknown>;
    const fillPolicy = normalizeSlotFillPolicy(targetSlotData.fillPolicy);
    const filledNodeIds = Array.isArray(targetSlotData.filledNodeIds)
      ? targetSlotData.filledNodeIds.filter((id) => typeof id === "string")
      : [];

    assertMediaItemsCompatibleWithAgentSlot({
      targetSlot,
      mediaItems,
    });

    if (params.baseCanvasWasStale && fillPolicy === "replace-existing") {
      throw new CanvasAgentMutationError(
        "画布已更新，替换 slot 前需要刷新并确认",
        409,
        "STALE_CANVAS_REVISION"
      );
    }

    if (fillPolicy === "replace-existing" && filledNodeIds.length > 0) {
      if (!isConfirmedHighRiskPlan(params.plan)) {
        throw new CanvasAgentMutationError(
          "当前 slot 已有结果，替换已有结果需要用户确认",
          409,
          "CANVAS_AGENT_CONFIRMATION_REQUIRED"
        );
      }
      replacedSlotNodeIds = removeCanvasNodesAndConnectedEdges({
        nodes,
        edges,
        nodeIds: filledNodeIds,
      });
    }
    if (fillPolicy === "replace-empty" && filledNodeIds.length > 0) {
      throw new CanvasAgentMutationError(
        "当前 slot 已被填充，请新建 slot 或使用追加版本",
        409,
        "CANVAS_AGENT_CONFLICT"
      );
    }
  }

  const createdNodeIds: string[] = [];
  const createdNodeIdsByMediaItemId: Record<string, string> = {};
  const createdEdgeIds: string[] = [];
  const updatedNodeIds: string[] = [];
  const placements = resolveCanvasAgentMediaPlacements({
    plan: params.plan,
    mediaItems,
    nodes,
    targetSlot,
    viewport: params.canvasData.viewport,
  });

  placements.forEach((placement) => {
    const node = buildMediaNode({
      item: placement.item,
      plan: params.plan,
      position: placement.position,
      size: placement.size,
      sourceNodeIds: placement.sourceNodeIds,
    });
    if (replacedSlotNodeIds.length > 0) {
      const nodeData = (node.data || {}) as Record<string, any>;
      (node as any).data = {
        ...nodeData,
        metadata: {
          ...(nodeData.metadata || {}),
          replacedSlotNodeIds,
          replacedSlotId: targetSlot?.id,
        },
      };
    }
    nodes.push(node);
    createdNodeIds.push(node.id);
    createdNodeIdsByMediaItemId[placement.item.mediaItemId] = node.id;

    const edgeSource = placement.edgeSourceId;
    if (edgeSource && edgeSource !== node.id) {
      const edge = buildEdge(
        edgeSource,
        node.id,
        params.plan.operation === "append_revision" ? "reference" : "default"
      );
      edges.push(edge);
      createdEdgeIds.push(edge.id);
    }

    if (targetSlot && params.plan.operation === "fill_slot") {
      const data = { ...(targetSlot.data || {}) };
      const filledNodeIds = Array.isArray(data.filledNodeIds)
        ? data.filledNodeIds
        : [];
      data.status = "completed";
      data.filledNodeIds =
        replacedSlotNodeIds.length > 0
          ? Array.from(new Set(createdNodeIds))
          : Array.from(new Set([...filledNodeIds, node.id]));
      data.metadata = {
        ...((data.metadata || {}) as Record<string, unknown>),
        ...(replacedSlotNodeIds.length > 0
          ? {
              replacedSlotNodeIds,
              replacedByCanvasAgentOperationId: params.plan.operationId,
              replacedAt: new Date().toISOString(),
            }
          : {}),
      };
      targetSlot.data = data;
      if (!updatedNodeIds.includes(targetSlot.id)) {
        updatedNodeIds.push(targetSlot.id);
      }
    }
  });

  rebuildConnections(nodes, edges);

  return {
    canvasData: {
      ...params.canvasData,
      nodes,
      edges,
      selectedNodeIds: createdNodeIds,
    },
    createdNodeIds,
    createdNodeIdsByMediaItemId,
    updatedNodeIds,
    createdEdgeIds,
  };
}

export function applyCanvasOperationPlanToCanvasData(params: {
  canvasData: CanvasDataLike;
  plan: CanvasOperationPlan;
  baseCanvasWasStale?: boolean;
}) {
  return applyOperationToCanvasData(params);
}

export async function applyCanvasOperationPlan(params: {
  userId: string;
  projectId: string;
  plan: CanvasOperationPlan;
}): Promise<CanvasOperationResult> {
  if (params.plan.projectId && params.plan.projectId !== params.projectId) {
    throw new CanvasAgentMutationError("operation projectId 与请求项目不一致");
  }

  const [project] = await db
    .select()
    .from(canvasProject)
    .where(
      and(
        eq(canvasProject.id, params.projectId),
        eq(canvasProject.userId, params.userId)
      )
    );

  if (!project) {
    throw new CanvasAgentMutationError("画布不存在", 404);
  }

  const currentCanvasData = normalizeCanvasData(project.canvasData);
  const baseCanvasWasStale = isPlanBaseStale(params.plan, project.updatedAt);
  const applied = applyOperationToCanvasData({
    canvasData: currentCanvasData,
    plan: {
      ...params.plan,
      projectId: params.projectId,
    },
    baseCanvasWasStale,
  });
  const existingAudit = findCanvasAgentOperationAudit(
    currentCanvasData,
    params.plan.operationId
  );
  if (existingAudit) {
    const currentRevision = project.updatedAt.toISOString();
    return {
      ...applied,
      canvasData: currentCanvasData,
      canvasRevision: currentRevision,
      canvasUpdatedAt: currentRevision,
      baseCanvasWasStale,
    };
  }

  const auditedCanvasData = appendCanvasAgentOperationAuditIfMissing({
    canvasData: applied.canvasData,
    plan: {
      ...params.plan,
      projectId: params.projectId,
    },
    result: applied,
  }) as CanvasDataLike;
  const { syncCanvasNodesForProject } = await import("@/lib/db/queries");
  const syncedCanvasData = await syncCanvasNodesForProject({
    projectId: params.projectId,
    userId: params.userId,
    canvasData: auditedCanvasData,
  });
  const updatedAt = new Date();
  const [updatedProject] = await db
    .update(canvasProject)
    .set({
      canvasData: syncedCanvasData,
      updatedAt,
    })
    .where(
      and(
        eq(canvasProject.id, params.projectId),
        eq(canvasProject.userId, params.userId)
      )
    )
    .returning();

  return {
    ...applied,
    canvasData: (updatedProject?.canvasData || syncedCanvasData) as CanvasDataLike,
    canvasRevision: updatedAt.toISOString(),
    canvasUpdatedAt: updatedAt.toISOString(),
    baseCanvasWasStale,
  };
}