import { describe, expect, test, vi } from "vitest";

import { registerBackgroundMessageHandler } from "../src/background/index";

describe("background-index", () => {
  test("downloads csv files when the content script sends a download message", async () => {
    const listeners: Array<
      (message: unknown, sender: unknown, sendResponse: (response: unknown) => void) => boolean | void
    > = [];
    const download = vi.fn(async () => undefined);
    const sendResponse = vi.fn();

    registerBackgroundMessageHandler({
      downloads: {
        download
      },
      runtime: {
        onMessage: {
          addListener(listener) {
            listeners.push(listener);
          }
        }
      }
    });

    expect(listeners).toHaveLength(1);
    const result = listeners[0](
      {
        csv: "列1,列2\n值1,值2",
        filename: "market.csv",
        type: "download-market-csv"
      },
      {},
      sendResponse
    );

    expect(result).toBe(true);
    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(download).toHaveBeenCalledTimes(1);
    expect(download).toHaveBeenCalledWith(
      expect.objectContaining({
        filename: "market.csv",
        saveAs: false,
        url: expect.stringContaining("data:text/csv;charset=utf-8,")
      })
    );
    expect(sendResponse).toHaveBeenCalledWith({ ok: true });
  });

  test("responds to auth:get-state with auth status", async () => {
    const listeners: Array<
      (message: unknown, sender: unknown, sendResponse: (response: unknown) => void) => boolean | void
    > = [];
    const sendResponse = vi.fn();

    registerBackgroundMessageHandler(
      {
        runtime: {
          onMessage: {
            addListener(listener) {
              listeners.push(listener);
            }
          }
        }
      },
      {
        authController: {
          getAccessToken: vi.fn(),
          getAuthState: vi.fn(async () => ({ isAuthenticated: false })),
          signIn: vi.fn(),
          signOut: vi.fn()
        }
      }
    );

    const result = listeners[0]({ type: "auth:get-state" }, {}, sendResponse);

    expect(result).toBe(true);
    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(sendResponse).toHaveBeenCalledWith({
      ok: true,
      type: "auth:state",
      value: { isAuthenticated: false }
    });
  });

  test("responds to auth:get-access-token with the current token", async () => {
    const listeners: Array<
      (message: unknown, sender: unknown, sendResponse: (response: unknown) => void) => boolean | void
    > = [];
    const sendResponse = vi.fn();

    registerBackgroundMessageHandler(
      {
        runtime: {
          onMessage: {
            addListener(listener) {
              listeners.push(listener);
            }
          }
        }
      },
      {
        authController: {
          getAccessToken: vi.fn(async () => "test-access-token"),
          getAuthState: vi.fn(),
          signIn: vi.fn(),
          signOut: vi.fn()
        }
      }
    );

    const result = listeners[0](
      { type: "auth:get-access-token" },
      {},
      sendResponse
    );

    expect(result).toBe(true);
    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(sendResponse).toHaveBeenCalledWith({
      ok: true,
      type: "auth:token",
      value: { accessToken: "test-access-token" }
    });
  });

  test("submits batches through the background message handler", async () => {
    const listeners: Array<
      (message: unknown, sender: unknown, sendResponse: (response: unknown) => void) => boolean | void
    > = [];
    const sendResponse = vi.fn();
    const submitBatch = vi.fn(async () => ({
      acceptedCount: 1,
      batchId: "批次A-2026-04-22T12:30:00.000Z",
      ok: true
    }));

    registerBackgroundMessageHandler(
      {
        runtime: {
          onMessage: {
            addListener(listener) {
              listeners.push(listener);
            }
          }
        }
      },
      {
        authController: {
          getAccessToken: vi.fn(async () => "test-access-token"),
          getAuthState: vi.fn(),
          signIn: vi.fn(),
          signOut: vi.fn()
        },
        submitBatch
      }
    );

    const result = listeners[0](
      {
        payload: {
          authors: [{ authorId: "111", authorName: "达人A" }],
          batchName: "批次A",
          createdAt: "2026-04-22T12:30:00.000Z",
          creatorName: "王少卿",
          logtoUserId: "p7pdhhtde8kj",
          resource: "https://talent-search.intelligrow.cn"
        },
        type: "batch:submit"
      },
      {},
      sendResponse
    );

    expect(result).toBe(true);
    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(submitBatch).toHaveBeenCalledWith(
      expect.objectContaining({
        batchName: "批次A"
      })
    );
    expect(submitBatch.mock.calls[0]?.[0]).not.toHaveProperty("batchId");
    expect(sendResponse).toHaveBeenCalledWith({
      ok: true,
      type: "batch:ack",
      value: {
        acceptedCount: 1,
        batchId: "批次A-2026-04-22T12:30:00.000Z",
        ok: true
      }
    });
  });

  test("searches backend metrics through the background message handler", async () => {
    const listeners: Array<
      (message: unknown, sender: unknown, sendResponse: (response: unknown) => void) => boolean | void
    > = [];
    const sendResponse = vi.fn();
    const searchBackendMetrics = vi.fn(async () => [
      {
        a3IncreaseCount: "78,366.22",
        afterViewSearchCount: "9,689.96",
        afterViewSearchRate: "0.36%",
        cpSearch: "14.46",
        cpa3: "1.79",
        newA3Rate: "3.44%",
        starId: "111"
      }
    ]);

    registerBackgroundMessageHandler(
      {
        runtime: {
          onMessage: {
            addListener(listener) {
              listeners.push(listener);
            }
          }
        }
      },
      {
        authController: {
          getAccessToken: vi.fn(async () => "test-access-token"),
          getAuthState: vi.fn(),
          signIn: vi.fn(),
          signOut: vi.fn()
        },
        searchBackendMetrics
      }
    );

    const result = listeners[0](
      {
        type: "backend-metrics:search",
        value: {
          starIds: ["111", "222"]
        }
      },
      {},
      sendResponse
    );

    expect(result).toBe(true);
    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(searchBackendMetrics).toHaveBeenCalledWith(["111", "222"]);
    expect(sendResponse).toHaveBeenCalledWith({
      ok: true,
      type: "backend-metrics:result",
      value: {
        rows: [
          {
            a3IncreaseCount: "78,366.22",
            afterViewSearchCount: "9,689.96",
            afterViewSearchRate: "0.36%",
            cpSearch: "14.46",
            cpa3: "1.79",
            newA3Rate: "3.44%",
            starId: "111"
          }
        ]
      }
    });
  });
});