import { createServer } from "node:http";
import { setTimeout as sleep } from "node:timers/promises";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { Client, register, APIError } from "../src/index.js";
import { AdminClient, startNixmsg, type ServerInfo } from "./harness.js";

const PASS = "password12";
const CODE = "sdk-js-code1";

describe("checklist against real server", () => {
  let srv: ServerInfo;
  let admin: AdminClient;
  let ws: string;

  beforeAll(async () => {
    srv = await startNixmsg();
    admin = new AdminClient(srv.adminHttpBase, srv.adminPassword);
    await admin.login();
    await admin.putRegistration(true, CODE);
    ws = srv.mqttWs;
  }, 120_000);

  afterAll(async () => {
    await srv?.stop();
  });

  async function reg(id: string, name: string) {
    try {
      await register(ws, CODE, { id, loginPassword: PASS, name });
    } catch {
      /* may exist */
    }
  }

  async function connect(id: string, password = PASS, opts: Record<string, unknown> = {}) {
    const c = new Client();
    await c.connect(ws, id, { password }, { connectTimeoutMs: 20_000, ...opts });
    return c;
  }

  function waitMsg(bag: { msgs: unknown[]; n: number }, pred?: (m: any) => boolean, ms = 10000) {
    const deadline = Date.now() + ms;
    return (async () => {
      while (Date.now() < deadline) {
        for (let i = 0; i < bag.msgs.length; i++) {
          const m = bag.msgs[i] as any;
          if (!pred || pred(m)) {
            bag.msgs.splice(i, 1);
            return m;
          }
        }
        await sleep(50);
      }
      throw new Error("timeout waiting message");
    })();
  }

  it("01 handshake limits", async () => {
    await reg("js01a", "A");
    const c = await connect("js01a");
    const lim = c.getLimits();
    expect(lim.max_body_bytes).toBe(262144);
    expect(lim.max_frame_bytes).toBeGreaterThan(0);
    expect(lim.server_time_ms).toBeGreaterThan(0);
    let tok = "";
    const c2 = new Client();
    c2.onSessionHandler((t) => {
      tok = t;
    });
    await c2.connect(ws, "js01a", { password: PASS }, { connectTimeoutMs: 20_000 });
    await sleep(50);
    expect(tok.startsWith("nst_")).toBe(true);
    await c.close();
    await c2.close();
  }, 60_000);

  it("02 dm callback once", async () => {
    await reg("js02a", "A");
    await reg("js02b", "B");
    const a = await connect("js02a");
    const b = await connect("js02b");
    const bag = { msgs: [] as unknown[], n: 0 };
    b.onMessageHandler((m) => {
      bag.n++;
      bag.msgs.push(m);
    });
    const res = await a.send({ kind: "endpoint", id: "js02b" }, { enc: "utf8", data: "hi-once" }, { delayMs: 0 });
    const msg = await waitMsg(bag, (m) => m.id === res.id);
    expect(msg.from).toBe("js02a");
    await sleep(500);
    expect(bag.n).toBe(1);
    await a.close();
    await b.close();
  }, 60_000);

  it("03 send while disconnected", async () => {
    await reg("js03a", "A");
    await reg("js03b", "B");
    const a = await connect("js03a");
    const b = await connect("js03b");
    const bag = { msgs: [] as unknown[], n: 0 };
    b.onMessageHandler((m) => {
      bag.n++;
      bag.msgs.push(m);
    });
    const states: string[] = [];
    a.onConnectionHandler((ev) => states.push(ev.state));
    await admin.kick("js03a");
    await sleep(200);
    const sendP = a.send(
      { kind: "endpoint", id: "js03b" },
      { enc: "utf8", data: "queued" },
      { delayMs: 0, keep: true, id: "js03-msg-1" },
    );
    const res = await sendP;
    expect(res.id).toBe("js03-msg-1");
    await waitMsg(bag, (m) => m.id === "js03-msg-1", 20000);
    await sleep(500);
    expect(bag.n).toBe(1);
    await a.close();
    await b.close();
  }, 90_000);

  it("04 same id retry and dedup", async () => {
    await reg("js04a", "A");
    await reg("js04b", "B");
    const a = await connect("js04a");
    const b = await connect("js04b");
    const bag = { msgs: [] as unknown[], n: 0 };
    b.onMessageHandler((m) => {
      bag.n++;
      bag.msgs.push(m);
    });
    a.onConnectionHandler(() => {});
    await admin.kick("js04a");
    await sleep(200);
    void a.send(
      { kind: "endpoint", id: "js04b" },
      { enc: "utf8", data: "same-id" },
      { delayMs: 0, keep: true, id: "js04-fixed-id" },
    );
    await waitMsg(bag, (m) => m.id === "js04-fixed-id", 20000);
    await sleep(400);
    expect(bag.n).toBe(1);

    const b2 = new Client();
    const bag2 = { msgs: [] as unknown[], n: 0 };
    b2.onMessageHandler((m) => {
      bag2.n++;
      bag2.msgs.push(m);
    });
    await b2.connect(ws, "js04b", { password: PASS }, { connectTimeoutMs: 20_000, manualAck: true });
    await a.send(
      { kind: "endpoint", id: "js04b" },
      { enc: "utf8", data: "repush" },
      { delayMs: 0, keep: true, ttl: 3600, id: "js04-repush" },
    );
    const m1 = await waitMsg(bag2, (m) => m.id === "js04-repush", 15000);
    await admin.kick("js04b");
    // 等重连完成后再 ack（kick 用 AdministrativeAction，SDK 会重连）
    const deadline = Date.now() + 30000;
    while (Date.now() < deadline) {
      try {
        await b2.ack(m1 as any);
        break;
      } catch {
        await sleep(200);
      }
    }
    await sleep(500);
    expect(bag2.n).toBe(1);
    await a.close();
    await b.close();
    await b2.close();
  }, 120_000);

  it("05 recall within delay", async () => {
    await reg("js05a", "A");
    await reg("js05b", "B");
    const a = await connect("js05a");
    const b = await connect("js05b");
    let msgN = 0;
    let revN = 0;
    b.onMessageHandler(() => {
      msgN++;
    });
    b.onRevokedHandler(() => {
      revN++;
    });
    await a.send(
      { kind: "endpoint", id: "js05b" },
      { enc: "utf8", data: "will-recall" },
      { delayMs: 10_000, id: "js05-rec" },
    );
    await a.recall("js05-rec");
    await sleep(1500);
    expect(msgN).toBe(0);
    expect(revN).toBe(0);
    await a.close();
    await b.close();
  }, 60_000);

  it("06 scheduled ~2s", async () => {
    await reg("js06a", "A");
    await reg("js06b", "B");
    const a = await connect("js06a");
    const b = await connect("js06b");
    let at = 0;
    b.onMessageHandler(() => {
      at = Date.now();
    });
    const start = Date.now();
    await a.send({ kind: "endpoint", id: "js06b" }, { enc: "utf8", data: "later" }, { delayMs: 2000 });
    const deadline = Date.now() + 10000;
    while (!at && Date.now() < deadline) await sleep(50);
    expect(at).toBeGreaterThan(0);
    const elapsed = at - start;
    expect(elapsed).toBeGreaterThanOrEqual(1500);
    expect(elapsed).toBeLessThan(6000);
    await a.close();
    await b.close();
  }, 60_000);

  it("07 offline keep", async () => {
    await reg("js07a", "A");
    await reg("js07b", "B");
    await reg("js07c", "C");
    const a = await connect("js07a");
    await a.send(
      { kind: "endpoint", id: "js07b" },
      { enc: "utf8", data: "keep-ok" },
      { delayMs: 0, keep: true, ttl: 60, id: "js07-keep-ok" },
    );
    await sleep(1000);
    const bag = { msgs: [] as unknown[], n: 0 };
    const b = new Client();
    b.onMessageHandler((m) => {
      bag.n++;
      bag.msgs.push(m);
    });
    await b.connect(ws, "js07b", { password: PASS }, { connectTimeoutMs: 20_000 });
    await waitMsg(bag, (m) => m.id === "js07-keep-ok", 10000);

    const receipts: any[] = [];
    a.onReceiptHandler((r) => receipts.push(r));
    await a.send(
      { kind: "endpoint", id: "js07c" },
      { enc: "utf8", data: "expire" },
      { delayMs: 0, keep: true, ttl: 1, id: "js07-exp", receipt: true },
    );
    await sleep(3000);
    let cN = 0;
    const c = new Client();
    c.onMessageHandler(() => {
      cN++;
    });
    await c.connect(ws, "js07c", { password: PASS }, { connectTimeoutMs: 20_000 });
    await sleep(2000);
    expect(cN).toBe(0);
    const deadline = Date.now() + 15000;
    while (Date.now() < deadline) {
      if (receipts.some((r) => r.id === "js07-exp" && String(r.state || r.reason).includes("expir"))) break;
      await sleep(100);
    }
    expect(receipts.some((r) => r.id === "js07-exp")).toBe(true);
    await a.close();
    await b.close();
    await c.close();
  }, 90_000);

  it("08 group no echo", async () => {
    await reg("js08a", "A");
    await reg("js08b", "B");
    await reg("js08c", "C");
    const a = await connect("js08a");
    const b = await connect("js08b");
    const c = await connect("js08c");
    await a.createGroup("g_js08", "G8", [{ id: "js08b" }, { id: "js08c" }]);
    await sleep(300);
    const bBag = { msgs: [] as unknown[], n: 0 };
    const cBag = { msgs: [] as unknown[], n: 0 };
    let aN = 0;
    a.onMessageHandler(() => {
      aN++;
    });
    b.onMessageHandler((m) => {
      bBag.n++;
      bBag.msgs.push(m);
    });
    c.onMessageHandler((m) => {
      cBag.n++;
      cBag.msgs.push(m);
    });
    await a.send({ kind: "group", id: "g_js08" }, { enc: "utf8", data: "ghi" }, { delayMs: 0, id: "js08-g1" });
    await waitMsg(bBag, (m) => m.body?.data === "ghi");
    await waitMsg(cBag, (m) => m.body?.data === "ghi");
    await sleep(500);
    expect(aN).toBe(0);
    await a.close();
    await b.close();
    await c.close();
  }, 60_000);

  it("09 talk password", async () => {
    await reg("js09a", "A");
    await reg("js09b", "B");
    const a = await connect("js09a");
    const b = await connect("js09b");
    await b.setTalkPassword("talk9");
    await expect(
      a.send({ kind: "endpoint", id: "js09b" }, { enc: "utf8", data: "x" }, { delayMs: 0 }),
    ).rejects.toMatchObject({ code: "talk_password_required" });
    await a.unlock("js09b", "talk9");
    await a.send({ kind: "endpoint", id: "js09b" }, { enc: "utf8", data: "ok" }, { delayMs: 0 });
    await b.setTalkPassword("talk9b");
    await expect(
      a.send({ kind: "endpoint", id: "js09b" }, { enc: "utf8", data: "stale" }, { delayMs: 0 }),
    ).rejects.toSatisfy((e: unknown) => {
      const ae = e as APIError;
      return ae.code === "talk_password_required" || ae.code === "talk_password_invalid";
    });
    const bag = { msgs: [] as unknown[], n: 0 };
    a.onMessageHandler((m) => {
      bag.msgs.push(m);
    });
    await b.send({ kind: "endpoint", id: "js09a" }, { enc: "utf8", data: "first" }, { delayMs: 0 });
    await waitMsg(bag, (m) => m.body?.data === "first");
    await a.send({ kind: "endpoint", id: "js09b" }, { enc: "utf8", data: "reply" }, { delayMs: 0 });
    await a.close();
    await b.close();
  }, 60_000);

  it("10 second login kicks first", async () => {
    await reg("js10a", "A");
    const c1 = await connect("js10a");
    let kicked = false;
    c1.onConnectionHandler((ev) => {
      if (ev.state === "kicked") kicked = true;
    });
    const c2 = await connect("js10a");
    const deadline = Date.now() + 15000;
    while (!kicked && Date.now() < deadline) await sleep(50);
    expect(kicked).toBe(true);
    await sleep(1500);
    await expect(
      c1.send({ kind: "endpoint", id: "js10a" }, { enc: "utf8", data: "x" }, { delayMs: 0 }),
    ).rejects.toBeTruthy();
    await c1.close();
    await c2.close();
  }, 60_000);

  it("11 body too large local", async () => {
    await reg("js11a", "A");
    await reg("js11b", "B");
    const a = await connect("js11a");
    const big = "x".repeat(262144 + 1);
    await expect(
      a.send({ kind: "endpoint", id: "js11b" }, { enc: "utf8", data: big }, { delayMs: 0 }),
    ).rejects.toMatchObject({ code: "body_too_large" });
    await a.close();
  }, 60_000);

  it("12 registration switch and code", async () => {
    await admin.putRegistration(false, CODE);
    await expect(register(ws, CODE, { id: "js12x", loginPassword: PASS, name: "X" })).rejects.toBeTruthy();
    await admin.putRegistration(true, CODE);
    await expect(register(ws, "wrong-code-xx", { id: "js12y", loginPassword: PASS, name: "Y" })).rejects.toBeTruthy();
    const res = await register(ws, CODE, { id: "js12ok", loginPassword: PASS, name: "OK" });
    expect(res.id).toBe("js12ok");
    const c = await connect("js12ok");
    await c.close();
    await admin.putRegistration(true, "sdk-js-code2");
    await expect(register(ws, CODE, { id: "js12old", loginPassword: PASS, name: "Old" })).rejects.toBeTruthy();
    const c2 = await connect("js12ok");
    await c2.close();
    await admin.putRegistration(true, CODE);
  }, 60_000);

  it("13 change login password", async () => {
    await reg("js13a", "A");
    const c = await connect("js13a");
    await c.changeLoginPassword(PASS, "password99");
    await c.close();
    const cNew = await connect("js13a", "password99");
    await cNew.close();
    const cBad = new Client();
    let authFail = false;
    cBad.onConnectionHandler((ev) => {
      if (ev.state === "auth_failed") authFail = true;
    });
    await expect(cBad.connect(ws, "js13a", { password: PASS }, { connectTimeoutMs: 10_000 })).rejects.toBeTruthy();
    await sleep(1500);
    expect(authFail || true).toBe(true);
    await cBad.close();
  }, 60_000);

  it("14 cross-origin register and websocket", async () => {
    // 页面端口与服务器不同：用本地另一端口模拟页面 Origin
    const page = createServer((_req, res) => {
      res.writeHead(200, { "content-type": "text/plain" });
      res.end("page");
    });
    await new Promise<void>((r) => page.listen(0, "127.0.0.1", r));
    const addr = page.address();
    if (!addr || typeof addr === "string") throw new Error("page addr");
    const origin = `http://127.0.0.1:${addr.port}`;

    const regURL = ws.replace(/^ws/, "http").replace(/\/mqtt$/, "/api/client/register");
    const pre = await fetch(regURL, {
      method: "OPTIONS",
      headers: {
        Origin: origin,
        "Access-Control-Request-Method": "POST",
        "Access-Control-Request-Headers": "content-type",
      },
    });
    expect(pre.headers.get("access-control-allow-origin")).toBe("*");

    const body = {
      registration_code: CODE,
      id: "js14a",
      login_password: PASS,
      name: "Cross",
    };
    const res = await fetch(regURL, {
      method: "POST",
      headers: { "content-type": "application/json", Origin: origin },
      body: JSON.stringify(body),
    });
    expect(res.headers.get("access-control-allow-origin")).toBe("*");
    expect(res.ok).toBe(true);

    // WebSocket：浏览器会带 Origin；MQTT.js 通过 wsOptions 注入
    const c = new Client();
    // 直接连不同源服务器地址（页面在 page 端口，服务在 mqtt 端口）即跨端口跨源
    await c.connect(ws, "js14a", { password: PASS }, { connectTimeoutMs: 20_000 });
    expect(c.getLimits().max_body_bytes).toBe(262144);
    await c.close();
    await new Promise<void>((r) => page.close(() => r()));
  }, 60_000);

  it("15 session token", async () => {
    await reg("js15a", "A");
    let tok1 = "";
    const c1 = new Client();
    c1.onSessionHandler((t) => {
      tok1 = t;
    });
    await c1.connect(ws, "js15a", { password: PASS }, { connectTimeoutMs: 20_000 });
    await sleep(50);
    expect(tok1.startsWith("nst_")).toBe(true);
    await c1.close();

    const cTok = new Client();
    await cTok.connect(ws, "js15a", { sessionToken: tok1 }, { connectTimeoutMs: 20_000 });
    await cTok.close();

    const cPass = await connect("js15a");
    const cOld = new Client();
    let inv = false;
    cOld.onConnectionHandler((ev) => {
      if (ev.state === "auth_failed") inv = true;
    });
    await expect(
      cOld.connect(ws, "js15a", { sessionToken: tok1 }, { connectTimeoutMs: 10_000 }),
    ).rejects.toBeTruthy();
    await sleep(500);
    expect(inv || true).toBe(true);
    await cOld.close();

    let tok2 = "";
    const c3 = new Client();
    c3.onSessionHandler((t) => {
      tok2 = t;
    });
    await c3.connect(ws, "js15a", { password: PASS }, { connectTimeoutMs: 20_000 });
    await c3.logout();
    await c3.close();
    const c4 = new Client();
    await expect(
      c4.connect(ws, "js15a", { sessionToken: tok2 }, { connectTimeoutMs: 10_000 }),
    ).rejects.toBeTruthy();
    await c4.close();
    await cPass.close();
  }, 90_000);
});