import { TaskRegistry } from "@umt/tasks";
import { createMockMteamApi, type MockMteamApi } from "@umt/testkit";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { snapshotSite } from "../../src/modules/sources-identity/service/snapshot.ts";
import { createHarness, type Harness, pgAvailable } from "./harness.ts";

const up = await pgAvailable();

describe.skipIf(!up)("M-Team 快照与任务注册", () => {
  let h: Harness;
  let api: MockMteamApi;
  let siteId: string;

  beforeAll(async () => {
    api = await createMockMteamApi();
    h = await createHarness("mteam");
    const site = await h.db
      .insertInto("site")
      .values({
        key: "mteam",
        name: "馒头",
        adapter: "mteam_api",
        base_url: "https://kp.m-team.cc/",
        rate_limit: JSON.stringify({ minIntervalMs: 0 }),
        config: JSON.stringify({ apiBaseUrl: api.baseUrl }),
      })
      .returningAll()
      .executeTakeFirstOrThrow();
    siteId = site.id;
    const ref = await h.secrets.create({ purpose: "site_api_key", plaintext: api.apiKey });
    await h.db
      .insertInto("site_account")
      .values({ site_id: siteId, label: "api", auth_kind: "api_key", secret_ref: ref })
      .execute();
  });
  afterAll(async () => {
    await h?.close();
    await api?.close();
  });

  it("API Key 站点快照:原始分类保留,促销带观察/过期时间;key 不入库", async () => {
    const r = await snapshotSite(h.rt, { siteId, kind: "periodic" });
    expect(r.status).toBe("ok");
    expect(r.itemCount).toBeGreaterThan(0);
    const rows = await h.db.selectFrom("source_release").selectAll().where("site_id", "=", siteId).execute();
    const sports = rows.find((x) => x.site_release_id === "912237");
    expect(sports?.category_raw).toBe("407");
    const promo = rows.find((x) => x.site_release_id === "912233")!;
    expect((promo.promotion as { observedAt?: string }).observedAt).toBeTruthy();
    expect(JSON.stringify(rows)).not.toContain(api.apiKey);
  });

  it("key 失效:账号标失效 + 待处理,快照结果 failed", async () => {
    api.setFailMode("banned_key");
    const r = await snapshotSite(h.rt, { siteId, kind: "manual" });
    expect(r.status).toBe("failed");
    const acc = await h.db
      .selectFrom("site_account")
      .select(["status"])
      .where("site_id", "=", siteId)
      .executeTakeFirstOrThrow();
    expect(["invalid", "expired"]).toContain(acc.status);
    const d = await h.db
      .selectFrom("decision")
      .selectAll()
      .where("dedupe_key", "=", `site-auth:${siteId}`)
      .executeTakeFirstOrThrow();
    expect(d.status).toBe("open");
    api.setFailMode(null);
  });

  it("模块注册 7 个任务与 3 条 outbox 路由;任务处理器经 step.run 调服务", async () => {
    const reg = new TaskRegistry();
    h.module.registerTasks(reg, h.ctx);
    expect(reg.names()).toEqual([
      "enrichPoolEntry",
      "ingestFeed",
      "refreshMetadata",
      "refreshSiteAccount",
      "resolveObservation",
      "searchSubscription",
      "snapshotSite",
    ]);
    expect(Object.keys(h.module.outboxRoutes!(h.ctx)).sort()).toEqual([
      "feed.due",
      "feed.gap_suspected",
      "release.observed",
    ]);
    const def = reg.latest("resolveObservation");
    expect(def.inputSchema.safeParse({}).success).toBe(false);
    expect(def.inputSchema.safeParse({ observationId: "00000000-0000-4000-8000-000000000000" }).success).toBe(true);
    const steps: string[] = [];
    const out = await reg.latest("snapshotSite").handler({
      input: { siteId, kind: "periodic" },
      step: {
        run: async (name: string, fn: () => unknown) => {
          steps.push(name);
          return fn();
        },
      },
    } as never);
    expect(steps).toEqual(["snapshot"]);
    expect(out).toMatchObject({ status: "skipped", reason: "auth_invalid" });
  });
});