import { html, stubNetwork } from "../../helpers.ts";
import { assert, assertEquals } from "@std/assert";
import { fetchRichContent } from "../../../services/rich-content-service.ts";

const BASE = "https://example.com/articles/1";

Deno.test("generic provider: the full fallback chain", async () => {
  using _ = stubNetwork(() =>
    html(`<html><head>
      <title>Page title</title>
      <meta property="og:site_name" content="Example">
      <meta property="og:title" content="OG title">
      <meta property="og:image" content="https://example.com/og.jpg">
      <meta name="description" content="Plain description">
      <meta name="theme-color" content="rgb(0, 128, 255)">
      <link rel="icon" href="/favicon-32.png" sizes="32x32">
    </head></html>`)
  );
  const content = await fetchRichContent(BASE);
  assertEquals(content, {
    type: "generic",
    url: BASE,
    title: "OG title",
    description: "Plain description",
    thumbnailUrl: "https://example.com/og.jpg",
    faviconUrl: "https://example.com/favicon-32.png",
    accentColor: "#0080ff",
    siteName: "Example",
  });
});

Deno.test("generic provider: a site-wide og:url means og:title/image are ignored", async () => {
  using _ = stubNetwork(() =>
    html(`
      <meta property="og:url" content="https://example.com/">
      <meta property="og:title" content="Site name">
      <meta property="og:image" content="https://example.com/site.jpg">
      <meta name="twitter:title" content="Article title">
      <img src="/photo.jpg">`)
  );
  const content = await fetchRichContent("https://www.example.com/articles/1");
  assertEquals(content?.title, "Article title");
  assertEquals(content?.thumbnailUrl, "https://www.example.com/photo.jpg");
  assertEquals(content?.siteName, "example.com");
  assertEquals(content?.faviconUrl, "https://www.example.com/favicon.ico");
});

Deno.test("generic provider: non-HTML responses carry just the URL", async () => {
  using _ = stubNetwork(() =>
    new Response("{}", { headers: { "content-type": "application/json" } })
  );
  assertEquals(await fetchRichContent(BASE), { type: "generic", url: BASE });
});

Deno.test("generic provider: a canonical og:url with a slug keeps the OG tags", async () => {
  using _ = stubNetwork(() =>
    html(`
      <meta property="og:url" content="https://example.com/q/123/how-to-x">
      <meta property="og:title" content="How to X">
      <meta property="og:image" content="https://example.com/x.jpg">
      <title>How to X - Example</title>`)
  );
  const content = await fetchRichContent("https://example.com/q/123");
  assertEquals(content?.title, "How to X");
  assertEquals(content?.thumbnailUrl, "https://example.com/x.jpg");
});

Deno.test("generic provider: relative URLs resolve against the page after redirects", async () => {
  using _ = stubNetwork((url) =>
    url.hostname === "old.example"
      ? new Response(null, {
        status: 301,
        headers: { location: "https://new.example/b/page" },
      })
      : html(`<meta property="og:image" content="/og.png">
              <meta name="twitter:image" content="https://new.example/tw.png">`)
  );
  const content = await fetchRichContent("https://old.example/a");
  assertEquals(content?.url, "https://old.example/a");
  assertEquals(content?.thumbnailUrl, "https://new.example/og.png");
  assertEquals(content?.faviconUrl, "https://new.example/favicon.ico");
});

Deno.test("generic provider: an og:image that isn't http(s) falls through", async () => {
  using _ = stubNetwork(() =>
    html(`<meta property="og:image" content="javascript:alert(1)">
          <meta name="twitter:image" content="//cdn.example/tw.png">`)
  );
  assertEquals(
    (await fetchRichContent(BASE))?.thumbnailUrl,
    "https://cdn.example/tw.png",
  );
});

Deno.test("generic provider: a <title> loses its site suffix", async () => {
  using _ = stubNetwork(() =>
    html(`<meta property="og:site_name" content="Le Monde">
          <title>Un article &eacute;crit — Le Monde</title>`)
  );
  const content = await fetchRichContent(BASE);
  assertEquals(content?.title, "Un article écrit");
  assertEquals(content?.siteName, "Le Monde");
});

Deno.test("generic provider: text on one line, and of bounded length", async () => {
  using _ = stubNetwork(() =>
    html(`<title>
            A title
            on two lines
          </title>
          <meta name="description" content="${"word ".repeat(400)}">`)
  );
  const content = await fetchRichContent(BASE);
  assertEquals(content?.title, "A title on two lines");
  assertEquals([...content!.description!].length, 1000);
  assert(content!.description!.endsWith("word…"));
});