import { expect, test } from "@playwright/test";
import {
  DEFAULT_VIDEO_CANVAS_NAME,
  duplicateVideoCanvasData,
  getNextVideoCanvasName,
  getVideoCanvasCopyName,
  getVideoCanvasWorkspaceProjects,
  normalizeVideoCanvasName,
  resolveVideoCanvasWorkspaceMeta,
  withVideoCanvasWorkspaceMeta,
} from "@/lib/canvas/video-workspace";

test.describe("video workspace canvases", () => {
  test("treats a legacy video project as the first canvas in its own workspace", () => {
    const legacy = { canvasData: { nodes: [] }, id: "root" };
    expect(resolveVideoCanvasWorkspaceMeta(legacy)).toEqual({
      canvasName: DEFAULT_VIDEO_CANVAS_NAME,
      workspaceId: "root",
    });
    expect(
      getVideoCanvasWorkspaceProjects(
        [
          legacy,
          {
            canvasData: withVideoCanvasWorkspaceMeta(null, {
              canvasName: "画布 2",
              workspaceId: "root",
            }),
            id: "child",
          },
          { canvasData: { nodes: [] }, id: "unrelated" },
        ],
        legacy,
      ).map((project) => project.id),
    ).toEqual(["root", "child"]);
  });

  test("normalizes names and chooses the first unused default number", () => {
    expect(normalizeVideoCanvasName("  空格画布  ")).toBe("空格画布");
    expect(normalizeVideoCanvasName("", "当前画布")).toBe("当前画布");
    expect(getNextVideoCanvasName(["画布 1", "画布 3"])).toBe("画布 2");
  });

  test("uses the observed copy suffix without overwriting an existing copy", () => {
    expect(getVideoCanvasCopyName("临时画布", [])).toBe("临时画布副本1");
    expect(getVideoCanvasCopyName("临时画布", ["临时画布副本1"])).toBe(
      "临时画布副本2",
    );
  });

  test("preserves canvas data while adding explicit workspace metadata", () => {
    const canvasData = withVideoCanvasWorkspaceMeta(
      {
        edges: [{ id: "edge-1" }],
        nodes: [{ id: "node-1" }],
        viewport: { x: 10, y: 20, zoom: 2 },
      },
      { canvasName: "测试画布", workspaceId: "workspace" },
    );
    expect(canvasData).toMatchObject({
      edges: [{ id: "edge-1" }],
      nodes: [{ id: "node-1" }],
      videoCanvasWorkspace: {
        canvasName: "测试画布",
        workspaceId: "workspace",
      },
      viewport: { x: 10, y: 20, zoom: 2 },
    });
  });

  test("duplicates node ids, nested group references, edges and selections", () => {
    let sequence = 0;
    const duplicate = duplicateVideoCanvasData(
      {
        edges: [{ id: "edge-old", source: "node-a", target: "node-b" }],
        nodes: [
          {
            data: {
              metadata: {
                liblibCloneNode: {
                  childNodeIds: ["node-b"],
                  id: "node-a",
                },
              },
            },
            id: "node-a",
          },
          {
            data: {
              metadata: {
                liblibCloneNode: { id: "node-b", parentGroupId: "node-a" },
              },
            },
            id: "node-b",
          },
        ],
        selectedNodeIds: ["node-a"],
      },
      { canvasName: "副本", workspaceId: "workspace" },
      () => `id-${++sequence}`,
    );

    expect(duplicate.nodes).toMatchObject([
      {
        data: {
          metadata: {
            liblibCloneNode: {
              childNodeIds: ["node-id-2"],
              id: "node-id-1",
            },
          },
        },
        id: "node-id-1",
      },
      {
        data: {
          metadata: {
            liblibCloneNode: {
              id: "node-id-2",
              parentGroupId: "node-id-1",
            },
          },
        },
        id: "node-id-2",
      },
    ]);
    expect(duplicate.edges).toEqual([
      { id: "edge-id-3", source: "node-id-1", target: "node-id-2" },
    ]);
    expect(duplicate.selectedNodeIds).toEqual(["node-id-1"]);
  });
});