import { beforeEach, describe, expect, test } from "vitest";
import { z } from "zod";

import {
  bookmarkLinks,
  bookmarks,
  bookmarkTexts,
  importStagingBookmarks,
} from "@karakeep/db/schema";
import { BookmarkTypes } from "@karakeep/shared/types/bookmarks";
import {
  zCreateImportSessionRequestSchema,
  zDeleteImportSessionRequestSchema,
  zGetImportSessionStatsRequestSchema,
} from "@karakeep/shared/types/importSessions";
import { zNewBookmarkListSchema } from "@karakeep/shared/types/lists";

import type { APICallerType, CustomTestContext } from "../testUtils";
import { defaultBeforeEach } from "../testUtils";

beforeEach<CustomTestContext>(defaultBeforeEach(true));

describe("ImportSessions Routes", () => {
  async function createTestList(api: APICallerType) {
    const newListInput: z.infer<typeof zNewBookmarkListSchema> = {
      name: "Test Import List",
      description: "A test list for imports",
      icon: "📋",
      type: "manual",
    };
    const createdList = await api.lists.create(newListInput);
    return createdList.id;
  }

  test<CustomTestContext>("create import session", async ({ apiCallers }) => {
    const api = apiCallers[0].importSessions;
    const listId = await createTestList(apiCallers[0]);

    const newSessionInput: z.infer<typeof zCreateImportSessionRequestSchema> = {
      name: "Test Import Session",
      rootListId: listId,
    };

    const createdSession = await api.createImportSession(newSessionInput);

    expect(createdSession).toMatchObject({
      id: expect.any(String),
    });

    // Verify session appears in list
    const sessions = await api.listImportSessions({});
    const sessionFromList = sessions.sessions.find(
      (s) => s.id === createdSession.id,
    );
    expect(sessionFromList).toBeDefined();
    expect(sessionFromList?.name).toEqual(newSessionInput.name);
    expect(sessionFromList?.rootListId).toEqual(listId);
  });

  test<CustomTestContext>("create import session without rootListId", async ({
    apiCallers,
  }) => {
    const api = apiCallers[0].importSessions;

    const newSessionInput: z.infer<typeof zCreateImportSessionRequestSchema> = {
      name: "Test Import Session",
    };

    const createdSession = await api.createImportSession(newSessionInput);

    expect(createdSession).toMatchObject({
      id: expect.any(String),
    });

    // Verify session appears in list
    const sessions = await api.listImportSessions({});
    const sessionFromList = sessions.sessions.find(
      (s) => s.id === createdSession.id,
    );
    expect(sessionFromList?.rootListId).toBeNull();
  });

  test<CustomTestContext>("get import session stats", async ({
    apiCallers,
  }) => {
    const api = apiCallers[0];

    const session = await api.importSessions.createImportSession({
      name: "Test Import Session",
    });

    // Stage bookmarks using the staging flow
    await api.importSessions.stageImportedBookmarks({
      importSessionId: session.id,
      bookmarks: [
        { type: "text", content: "Test bookmark 1", tags: [], listIds: [] },
        { type: "text", content: "Test bookmark 2", tags: [], listIds: [] },
      ],
    });

    const statsInput: z.infer<typeof zGetImportSessionStatsRequestSchema> = {
      importSessionId: session.id,
    };

    const stats = await api.importSessions.getImportSessionStats(statsInput);

    expect(stats).toMatchObject({
      id: session.id,
      name: "Test Import Session",
      status: "staging",
      totalBookmarks: 2,
      pendingBookmarks: 2,
      completedBookmarks: 0,
      failedBookmarks: 0,
      processingBookmarks: 0,
    });
  });

  test<CustomTestContext>("stats reflect crawl and tagging status for completed staging bookmarks", async ({
    apiCallers,
    db,
  }) => {
    const api = apiCallers[0];

    const session = await api.importSessions.createImportSession({
      name: "Test Import Session",
    });

    // Create bookmarks with different crawl/tag statuses
    const user = (await db.query.users.findFirst())!;

    // 1. Link bookmark: crawl success, tag success -> completed
    const [completedLinkBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.LINK,
        taggingStatus: "success",
      })
      .returning();
    await db.insert(bookmarkLinks).values({
      id: completedLinkBookmark.id,
      url: "https://example.com/1",
      crawlStatus: "success",
    });

    // 2. Link bookmark: crawl pending, tag success -> processing
    const [crawlPendingBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.LINK,
        taggingStatus: "success",
      })
      .returning();
    await db.insert(bookmarkLinks).values({
      id: crawlPendingBookmark.id,
      url: "https://example.com/2",
      crawlStatus: "pending",
    });

    // 3. Text bookmark: tag pending -> processing
    const [tagPendingBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.TEXT,
        taggingStatus: "pending",
      })
      .returning();
    await db.insert(bookmarkTexts).values({
      id: tagPendingBookmark.id,
      text: "Test text",
    });

    // 4. Link bookmark: crawl failure -> failed
    const [crawlFailedBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.LINK,
        taggingStatus: "success",
      })
      .returning();
    await db.insert(bookmarkLinks).values({
      id: crawlFailedBookmark.id,
      url: "https://example.com/3",
      crawlStatus: "failure",
    });

    // 5. Text bookmark: tag failure -> failed
    const [tagFailedBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.TEXT,
        taggingStatus: "failure",
      })
      .returning();
    await db.insert(bookmarkTexts).values({
      id: tagFailedBookmark.id,
      text: "Test text 2",
    });

    // 6. Text bookmark: tag success (no crawl needed) -> completed
    const [completedTextBookmark] = await db
      .insert(bookmarks)
      .values({
        userId: user.id,
        type: BookmarkTypes.TEXT,
        taggingStatus: "success",
      })
      .returning();
    await db.insert(bookmarkTexts).values({
      id: completedTextBookmark.id,
      text: "Test text 3",
    });

    // Create staging bookmarks in different states
    // Note: With the new import worker design, items stay in "processing" until
    // crawl/tag is done. Only then do they move to "completed".
    await db.insert(importStagingBookmarks).values([
      // Staging pending -> pendingBookmarks
      {
        importSessionId: session.id,
        type: "text",
        content: "pending staging",
        status: "pending",
      },
      // Staging processing (no bookmark yet) -> processingBookmarks
      {
        importSessionId: session.id,
        type: "text",
        content: "processing staging",
        status: "processing",
      },
      // Staging failed -> failedBookmarks
      {
        importSessionId: session.id,
        type: "text",
        content: "failed staging",
        status: "failed",
      },
      // Staging completed + crawl/tag success -> completedBookmarks
      {
        importSessionId: session.id,
        type: "link",
        url: "https://example.com/1",
        status: "completed",
        resultBookmarkId: completedLinkBookmark.id,
      },
      // Staging processing + crawl pending -> processingBookmarks (waiting for crawl)
      {
        importSessionId: session.id,
        type: "link",
        url: "https://example.com/2",
        status: "processing",
        resultBookmarkId: crawlPendingBookmark.id,
      },
      // Staging processing + tag pending -> processingBookmarks (waiting for tag)
      {
        importSessionId: session.id,
        type: "text",
        content: "tag pending",
        status: "processing",
        resultBookmarkId: tagPendingBookmark.id,
      },
      // Staging completed + crawl failure -> completedBookmarks (failure is terminal)
      {
        importSessionId: session.id,
        type: "link",
        url: "https://example.com/3",
        status: "completed",
        resultBookmarkId: crawlFailedBookmark.id,
      },
      // Staging completed + tag failure -> completedBookmarks (failure is terminal)
      {
        importSessionId: session.id,
        type: "text",
        content: "tag failed",
        status: "completed",
        resultBookmarkId: tagFailedBookmark.id,
      },
      // Staging completed + tag success (text, no crawl) -> completedBookmarks
      {
        importSessionId: session.id,
        type: "text",
        content: "completed text",
        status: "completed",
        resultBookmarkId: completedTextBookmark.id,
      },
    ]);

    const stats = await api.importSessions.getImportSessionStats({
      importSessionId: session.id,
    });

    expect(stats).toMatchObject({
      totalBookmarks: 9,
      pendingBookmarks: 1, // staging pending
      processingBookmarks: 3, // staging processing (no bookmark) + crawl pending + tag pending
      completedBookmarks: 4, // link success + text success + crawl failure + tag failure
      failedBookmarks: 1, // staging failed
    });
  });

  test<CustomTestContext>("list import sessions returns all sessions", async ({
    apiCallers,
  }) => {
    const api = apiCallers[0].importSessions;

    const sessionNames = ["Session 1", "Session 2", "Session 3"];
    for (const name of sessionNames) {
      await api.createImportSession({ name });
    }

    const result = await api.listImportSessions({});

    expect(result.sessions).toHaveLength(3);
    expect(result.sessions.map((session) => session.name)).toEqual(
      sessionNames,
    );
    expect(
      result.sessions.every((session) => session.totalBookmarks === 0),
    ).toBe(true);
  });

  test<CustomTestContext>("delete import session", async ({ apiCallers }) => {
    const api = apiCallers[0].importSessions;

    const session = await api.createImportSession({
      name: "Session to Delete",
    });

    const deleteInput: z.infer<typeof zDeleteImportSessionRequestSchema> = {
      importSessionId: session.id,
    };

    const result = await api.deleteImportSession(deleteInput);
    expect(result.success).toBe(true);

    // Verify session no longer exists
    await expect(
      api.getImportSessionStats({
        importSessionId: session.id,
      }),
    ).rejects.toThrow("Import session not found");
  });

  test<CustomTestContext>("cannot access other user's session", async ({
    apiCallers,
  }) => {
    const api1 = apiCallers[0].importSessions;
    const api2 = apiCallers[1].importSessions;

    // User 1 creates a session
    const session = await api1.createImportSession({
      name: "User 1 Session",
    });

    // User 2 tries to access it
    await expect(
      api2.getImportSessionStats({
        importSessionId: session.id,
      }),
    ).rejects.toThrow("Import session not found");

    await expect(
      api2.deleteImportSession({
        importSessionId: session.id,
      }),
    ).rejects.toThrow("Import session not found");
  });

  test<CustomTestContext>("cannot stage other user's session", async ({
    apiCallers,
  }) => {
    const api1 = apiCallers[0];
    const api2 = apiCallers[1];

    // User 1 creates session and bookmark
    const session = await api1.importSessions.createImportSession({
      name: "User 1 Session",
    });

    // User 1 tries to attach User 2's bookmark
    await expect(
      api2.importSessions.stageImportedBookmarks({
        importSessionId: session.id,
        bookmarks: [
          {
            type: "text",
            content: "Test bookmark",
            tags: [],
            listIds: [],
          },
        ],
      }),
    ).rejects.toThrow("Import session not found");
  });
});