// @vitest-environment jsdom
//
// One-click share (E7 S3 · D2-A): quickShareLink turns the row's Share button into a single action —
// ensure a public link (mint on demand, downloadable per D1), copy it, and toast with an "open in new
// tab" action. These pin the branch matrix: reuse-vs-mint, copy-ok-vs-fail, and the create-failure path.
import { describe, it, expect, beforeEach, vi } from "vitest";
import { QueryClient } from "@tanstack/react-query";

// vi.mock is hoisted above these consts, so the mock fns must live in a hoisted block too.
const { downloadLinks, createDownloadLink, copyText, notify } = vi.hoisted(() => ({
  downloadLinks: vi.fn(),
  createDownloadLink: vi.fn(),
  copyText: vi.fn(),
  notify: vi.fn(),
}));

vi.mock("./api", () => ({ api: { downloadLinks, createDownloadLink } }));
vi.mock("./clipboard", () => ({ copyText }));
vi.mock("./notifications", () => ({ notify }));

import { quickShareLink } from "./downloads";

const t = (k: string) => k;
const origin = window.location.origin;

type ToastArg = {
  level: string;
  message: string;
  action?: { label: string; onClick: () => void };
};
const firstToast = () => notify.mock.calls[0]![0] as ToastArg;

function qc() {
  return new QueryClient({ defaultOptions: { queries: { retry: false } } });
}

beforeEach(() => {
  downloadLinks.mockReset();
  createDownloadLink.mockReset();
  copyText.mockReset().mockResolvedValue(true);
  notify.mockReset();
});

describe("quickShareLink", () => {
  it("mints a downloadable link on demand, copies it, and toasts with an open-in-new-tab action", async () => {
    downloadLinks.mockResolvedValue([]); // none yet
    createDownloadLink.mockResolvedValue({ id: 7, url: "/watch/tok7" });
    const openSpy = vi.spyOn(window, "open").mockReturnValue(null);

    const url = await quickShareLink(qc(), { id: 42 }, t);

    expect(url).toBe(`${origin}/watch/tok7`);
    // Minted with an EMPTY body so the backend D1 default (allow_download=true) applies.
    expect(createDownloadLink).toHaveBeenCalledWith(42, {});
    expect(copyText).toHaveBeenCalledWith(`${origin}/watch/tok7`);
    const arg = firstToast();
    expect(arg.level).toBe("success");
    expect(arg.message).toBe("downloads.share.linkCopied");
    expect(arg.action!.label).toBe("downloads.share.openNewTab");
    arg.action!.onClick();
    expect(openSpy).toHaveBeenCalledWith(`${origin}/watch/tok7`, "_blank", "noopener,noreferrer");
  });

  it("reuses an existing link instead of minting a duplicate", async () => {
    downloadLinks.mockResolvedValue([{ id: 3, url: "/watch/old" }]);

    const url = await quickShareLink(qc(), { id: 1 }, t);

    expect(url).toBe(`${origin}/watch/old`);
    expect(createDownloadLink).not.toHaveBeenCalled();
    expect(firstToast().level).toBe("success");
  });

  it("still toasts (warning) with the open action when the clipboard copy fails", async () => {
    downloadLinks.mockResolvedValue([{ id: 5, url: "/watch/x" }]);
    copyText.mockResolvedValue(false);

    const url = await quickShareLink(qc(), { id: 2 }, t);

    expect(url).toBe(`${origin}/watch/x`); // the link is never a dead end
    const arg = firstToast();
    expect(arg.level).toBe("warning");
    expect(arg.message).toBe("downloads.share.copyFailed");
    expect(arg.action!.label).toBe("downloads.share.openNewTab");
  });

  it("reports an error and returns null when link creation fails", async () => {
    downloadLinks.mockResolvedValue([]);
    createDownloadLink.mockRejectedValue(new Error("boom"));

    const url = await quickShareLink(qc(), { id: 9 }, t);

    expect(url).toBeNull();
    expect(copyText).not.toHaveBeenCalled();
    // Titled with what failed, and carrying why (notifyActionError), not a bare message.
    expect(notify).toHaveBeenCalledWith(
      expect.objectContaining({ level: "error", title: "downloads.share.linkFailed" }),
    );
  });
});