import { describe, expect, test } from "bun:test";
import { existsSync } from "node:fs";
import { chromium } from "playwright-core";
import type { InvoiceTemplateConfig } from "../db/schema";
import {
  buildInvoiceHtmlDocument,
  getInvoicePdfRenderOptions,
  renderInvoiceHtmlPdf,
} from "./render-html-pdf";
import { DEFAULT_HTML_TEMPLATE_CONFIG } from "./templates-html";
import type { InvoiceTemplateData } from "./templates-html/types";

// Real Chromium is only available when a prior `playwright install chromium`
// has run. Browser-dependent assertions are gated on this so CI never
// downloads a browser or hits the network to pass.
function chromiumAvailable(): boolean {
  try {
    const path = chromium.executablePath();
    return typeof path === "string" && path.length > 0 && existsSync(path);
  } catch {
    return false;
  }
}

const available = chromiumAvailable();

const invoice: InvoiceTemplateData = {
  invoiceNumber: "INV-2602",
  issueDate: "2026-06-01",
  dueDate: "2026-06-15",
  periodStart: "2026-05-01",
  periodEnd: "2026-05-31",
  clientName: "Acme Corp",
  clientEmail: "ap@acme.example",
  clientAddress: "1 Market St\nSan Francisco, CA",
  subtotal: 250000,
  taxRate: 850,
  taxAmount: 21250,
  total: 271250,
  currency: "USD",
  notes: "Thanks for the great collaboration.",
  paymentNotes: "Wire to account 1234567890.",
  lineItems: [
    {
      id: "li-1",
      description: "Engineering - 12.5 hours",
      quantity: 750,
      rate: 20000,
      amount: 250000,
      projectName: "Platform",
      projectColor: "#22d3ee",
    },
  ],
};

const config: InvoiceTemplateConfig = {
  ...DEFAULT_HTML_TEMPLATE_CONFIG,
  companyName: "Studio Scribe",
  companyEmail: "billing@scribe.example",
};

describe("invoice PDF render options", () => {
  test("uses zero margins only for the full-bleed mandala template", () => {
    expect(getInvoicePdfRenderOptions("mandala")).toEqual({
      paperSize: "Letter",
      printBackground: true,
      margin: "0",
    });
    expect(getInvoicePdfRenderOptions("minimal")).toEqual({
      paperSize: "Letter",
      printBackground: true,
    });
    expect(getInvoicePdfRenderOptions("does-not-exist", "a4")).toEqual({
      paperSize: "A4",
      printBackground: true,
    });
  });
});

describe("buildInvoiceHtmlDocument (pure, no browser)", () => {
  test("emits a full self-contained document with print CSS and root vars", async () => {
    const html = await buildInvoiceHtmlDocument({ invoice, config });
    expect(html.startsWith("<!doctype html>")).toBe(true);
    // Template markup is inlined.
    expect(html).toContain("scribe-invoice");
    expect(html).toContain("INV-2602");
    // Shared print base + @page rule are present in <head>.
    expect(html).toContain("@page");
    expect(html).toContain("print-color-adjust");
    // configToCssVars palette is placed on :root.
    expect(html).toContain("--inv-primary");
  });

  test("defaults to the minimal template and honors mandala selection", async () => {
    const minimal = await buildInvoiceHtmlDocument({ invoice, config });
    expect(minimal).toContain("t-minimal");
    const mandala = await buildInvoiceHtmlDocument({
      invoice,
      config,
      templateName: "mandala",
    });
    expect(mandala).toContain("t-mandala");
  });

  test("passes a data: URI logo through unchanged", async () => {
    const dataLogo = "data:image/png;base64,AAAA";
    const html = await buildInvoiceHtmlDocument({
      invoice,
      config: { ...config, logo: dataLogo, showLogo: true },
    });
    // Document builds without throwing; data URIs are never fetched.
    expect(html.startsWith("<!doctype html>")).toBe(true);
  });

  test("never fetches a remote (http/https) logo URL and omits it (SSRF guard)", async () => {
    const originalFetch = globalThis.fetch;
    let fetchCalls = 0;
    globalThis.fetch = (async (...args: Parameters<typeof fetch>) => {
      fetchCalls++;
      return originalFetch(...args);
    }) as typeof fetch;
    try {
      // A URL that would be an SSRF target if fetched server-side.
      const html = await buildInvoiceHtmlDocument({
        invoice,
        config: {
          ...config,
          logo: "http://169.254.169.254/latest/meta-data/",
          showLogo: true,
        },
      });
      // No outbound request at all, and the logo is not embedded.
      expect(fetchCalls).toBe(0);
      expect(html).not.toContain("169.254.169.254");
      expect(html.startsWith("<!doctype html>")).toBe(true);
    } finally {
      globalThis.fetch = originalFetch;
    }
  });

  test("a poisoned per-line project color cannot inject CSS into the render", async () => {
    for (const payload of [
      "red; color: evil",
      "red;}</style><script>x</script>",
    ]) {
      const html = await buildInvoiceHtmlDocument({
        invoice: {
          ...invoice,
          lineItems: [{ ...invoice.lineItems[0], projectColor: payload }],
        },
        config,
      });
      // The raw value never appears and no extra declaration / tag is injected;
      // a non-hex color drops the project dot entirely.
      expect(html).not.toContain(payload);
      expect(html).not.toContain("color: evil");
      expect(html).not.toContain("<script");
      expect(html).not.toContain("</style><script>");
    }
  });

  test("validates config: a poisoned color cannot break out of the <style> block", async () => {
    const payload = "red;}</style><script>fetch('https://evil')</script>";
    const html = await buildInvoiceHtmlDocument({
      invoice,
      config: {
        ...config,
        // Inject through every field that reaches the raw <style> CSS vars.
        primaryColor: payload,
        accentColor: payload,
        textColor: payload,
      } as typeof config,
    });
    // The raw payload must never appear, and no injected tags exist.
    expect(html).not.toContain(payload);
    expect(html).not.toContain("</style><script>");
    expect(html).not.toContain("evil");
    // Exactly the two legitimate <style> blocks remain (head + template frame):
    // the document is not broken out of.
    expect(html).not.toContain("<script");
    // The poisoned color fell back to a safe hex default on :root.
    expect(html).toMatch(/--inv-primary:\s*#[0-9a-fA-F]{3,8};/);
  });
});

describe("renderInvoiceHtmlPdf produces a valid PDF", () => {
  test.skipIf(!available)(
    "renders the minimal template to %PDF- bytes",
    async () => {
      const bytes = await renderInvoiceHtmlPdf({ invoice, config });
      expect(bytes).toBeInstanceOf(Uint8Array);
      expect(bytes.byteLength).toBeGreaterThan(1000);
      const header = new TextDecoder().decode(bytes.slice(0, 5));
      expect(header).toBe("%PDF-");
    },
    30_000, // real browser launch + render exceeds the 5s default
  );

  test.skipIf(!available)(
    "renders the mandala template to %PDF- bytes",
    async () => {
      const bytes = await renderInvoiceHtmlPdf({
        invoice,
        config,
        templateName: "mandala",
      });
      expect(bytes).toBeInstanceOf(Uint8Array);
      expect(bytes.byteLength).toBeGreaterThan(1000);
      const header = new TextDecoder().decode(bytes.slice(0, 5));
      expect(header).toBe("%PDF-");
    },
    30_000, // real browser launch + render exceeds the 5s default
  );
});