import { assert, beforeEach, describe, expect, inject, it } from "vitest";

import { createKarakeepClient } from "@karakeep/sdk";

import { createTestUser } from "../../utils/api";
import { waitUntil } from "../../utils/general";
import { getTrpcClient } from "../../utils/trpc";

describe("Import Worker Tests", () => {
  const port = inject("karakeepPort");

  if (!port) {
    throw new Error("Missing required environment variables");
  }

  let client: ReturnType<typeof createKarakeepClient>;
  let trpc: ReturnType<typeof getTrpcClient>;
  let apiKey: string;

  beforeEach(async () => {
    apiKey = await createTestUser();
    client = createKarakeepClient({
      baseUrl: `http://localhost:${port}/api/v1/`,
      headers: {
        "Content-Type": "application/json",
        authorization: `Bearer ${apiKey}`,
      },
    });
    trpc = getTrpcClient(apiKey);
  });

  it("should import 15 bookmarks of different types", async () => {
    // Create lists first (lists require IDs, not paths)
    const { data: parentList } = await client.POST("/lists", {
      body: {
        name: "Import Test List",
        icon: "folder",
      },
    });
    assert(parentList);

    const { data: nestedList } = await client.POST("/lists", {
      body: {
        name: "Nested",
        icon: "folder",
        parentId: parentList.id,
      },
    });
    assert(nestedList);

    // Create a root list that all imported bookmarks will be attached to
    const { data: rootList } = await client.POST("/lists", {
      body: {
        name: "Import Root List",
        icon: "folder",
      },
    });
    assert(rootList);

    // Create an import session with rootListId
    const { id: importSessionId } =
      await trpc.importSessions.createImportSession.mutate({
        name: "E2E Test Import",
        rootListId: rootList.id,
      });
    assert(importSessionId);

    // Define 15 bookmarks of different types
    const bookmarksToImport = [
      // Links (7 total, with varying metadata)
      {
        type: "link" as const,
        url: "http://nginx:80/hello.html",
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page1.html",
        title: "Page 1 Title",
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page2.html",
        title: "Page 2 with Note",
        note: "This is a note for page 2",
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page3.html",
        title: "Page 3 with Tags",
        tags: ["tag1", "tag2"],
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page4.html",
        title: "Page 4 with List",
        listIds: [parentList.id],
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page5.html",
        title: "Page 5 with Source Date",
        sourceAddedAt: new Date("2024-01-15T10:30:00Z"),
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page6.html",
        title: "Page 6 Full Metadata",
        note: "Full metadata note",
        tags: ["imported", "full"],
        listIds: [nestedList.id],
        sourceAddedAt: new Date("2024-02-20T15:45:00Z"),
      },

      // Text bookmarks (5 total)
      {
        type: "text" as const,
        content: "This is a basic text bookmark content.",
      },
      {
        type: "text" as const,
        title: "Text with Title",
        content: "Text bookmark with a title.",
      },
      {
        type: "text" as const,
        title: "Text with Tags",
        content: "Text bookmark with tags attached.",
        tags: ["text-tag", "imported"],
      },
      {
        type: "text" as const,
        title: "Text with Note",
        content: "Text bookmark content here.",
        note: "A note attached to this text bookmark.",
      },
      {
        type: "text" as const,
        title: "Text Full Metadata",
        content: "Text bookmark with all metadata fields.",
        note: "Complete text note",
        tags: ["complete", "text"],
        listIds: [parentList.id],
        sourceAddedAt: new Date("2024-03-10T08:00:00Z"),
      },

      // Duplicates (3 total - same URLs as earlier links)
      {
        type: "link" as const,
        url: "http://nginx:80/hello.html", // Duplicate of link #1
        title: "Duplicate of Hello",
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page1.html", // Duplicate of link #2
        title: "Duplicate of Page 1",
      },
      {
        type: "link" as const,
        url: "http://nginx:80/page2.html", // Duplicate of link #3
        title: "Duplicate of Page 2",
        note: "Different note but same URL",
      },
    ];

    // Stage all bookmarks
    await trpc.importSessions.stageImportedBookmarks.mutate({
      importSessionId,
      bookmarks: bookmarksToImport,
    });

    // Finalize the import to trigger processing
    await trpc.importSessions.finalizeImportStaging.mutate({
      importSessionId,
    });

    // Wait for all bookmarks to be processed
    await waitUntil(
      async () => {
        const stats = await trpc.importSessions.getImportSessionStats.query({
          importSessionId,
        });
        const allProcessed =
          stats.completedBookmarks + stats.failedBookmarks ===
          stats.totalBookmarks;
        console.log(
          `Import progress: ${stats.completedBookmarks} completed, ${stats.failedBookmarks} failed, ${stats.totalBookmarks} total`,
        );
        return allProcessed && stats.totalBookmarks === 15;
      },
      "All bookmarks are processed",
      120000, // 2 minutes timeout
    );

    // Get final stats
    const finalStats = await trpc.importSessions.getImportSessionStats.query({
      importSessionId,
    });

    expect(finalStats.totalBookmarks).toBe(15);
    expect(finalStats.completedBookmarks).toBe(15);
    expect(finalStats.failedBookmarks).toBe(0);
    expect(finalStats.status).toBe("completed");

    // Get results by filter
    const acceptedResults =
      await trpc.importSessions.getImportSessionResults.query({
        importSessionId,
        filter: "accepted",
        limit: 50,
      });

    const duplicateResults =
      await trpc.importSessions.getImportSessionResults.query({
        importSessionId,
        filter: "skipped_duplicate",
        limit: 50,
      });

    // We expect 12 accepted (7 links + 5 text) and 3 duplicates
    expect(acceptedResults.items.length).toBe(12);
    expect(duplicateResults.items.length).toBe(3);

    // Verify duplicates reference the original bookmarks
    for (const dup of duplicateResults.items) {
      expect(dup.resultBookmarkId).toBeDefined();
      expect(dup.result).toBe("skipped_duplicate");
    }

    // Verify accepted bookmarks have resultBookmarkId
    for (const accepted of acceptedResults.items) {
      expect(accepted.resultBookmarkId).toBeDefined();
      expect(accepted.result).toBe("accepted");
    }

    // Verify actual bookmarks were created via the API
    const { data: allBookmarks } = await client.GET("/bookmarks", {
      params: {
        query: {
          limit: 50,
        },
      },
    });
    assert(allBookmarks);

    // Should have 12 unique bookmarks (7 links + 5 text)
    expect(allBookmarks.bookmarks.length).toBe(12);

    // Verify link bookmarks
    const linkBookmarks = allBookmarks.bookmarks.filter(
      (b) => b.content.type === "link",
    );
    expect(linkBookmarks.length).toBe(7);

    // Verify text bookmarks
    const textBookmarks = allBookmarks.bookmarks.filter(
      (b) => b.content.type === "text",
    );
    expect(textBookmarks.length).toBe(5);

    // Verify tags were created
    const { data: tagsResponse } = await client.GET("/tags", {});
    assert(tagsResponse);
    const tagNames = tagsResponse.tags.map((t) => t.name);
    expect(tagNames).toContain("tag1");
    expect(tagNames).toContain("tag2");
    expect(tagNames).toContain("imported");
    expect(tagNames).toContain("text-tag");
    expect(tagNames).toContain("complete");

    // Verify tags are actually attached to bookmarks
    // Find a bookmark with tags and verify
    const bookmarkWithTags = allBookmarks.bookmarks.find((b) =>
      b.tags.some((t) => t.name === "tag1"),
    );
    assert(bookmarkWithTags, "Should find a bookmark with tag1");
    expect(bookmarkWithTags.tags.map((t) => t.name)).toContain("tag1");
    expect(bookmarkWithTags.tags.map((t) => t.name)).toContain("tag2");

    // Verify "imported" tag is on multiple bookmarks (used in link and text)
    const bookmarksWithImportedTag = allBookmarks.bookmarks.filter((b) =>
      b.tags.some((t) => t.name === "imported"),
    );
    expect(bookmarksWithImportedTag.length).toBeGreaterThanOrEqual(2);

    // Verify bookmarks are actually in the lists
    const { data: parentListBookmarks } = await client.GET(
      "/lists/{listId}/bookmarks",
      {
        params: {
          path: { listId: parentList.id },
        },
      },
    );
    assert(parentListBookmarks);
    // Should have bookmarks with listIds containing parentList.id
    expect(parentListBookmarks.bookmarks.length).toBeGreaterThanOrEqual(2);

    // Verify nested list has bookmarks
    const { data: nestedListBookmarks } = await client.GET(
      "/lists/{listId}/bookmarks",
      {
        params: {
          path: { listId: nestedList.id },
        },
      },
    );
    assert(nestedListBookmarks);
    // Should have the bookmark with listIds containing nestedList.id
    expect(nestedListBookmarks.bookmarks.length).toBeGreaterThanOrEqual(1);

    // Verify ALL imported bookmarks are in the root list (via rootListId)
    const { data: rootListBookmarks } = await client.GET(
      "/lists/{listId}/bookmarks",
      {
        params: {
          path: { listId: rootList.id },
        },
      },
    );
    assert(rootListBookmarks);
    // All 12 unique bookmarks should be in the root list
    expect(rootListBookmarks.bookmarks.length).toBe(12);
  });
});