import { test } from "node:test";
import assert from "node:assert/strict";
import {
  DEFAULT_COOKIE_MODE,
  alwaysCookies,
  authRetryCookies,
  cookieArgs,
  isCookieMode,
  resolveCookiePolicy,
  type ResolvedCookiePolicy,
} from "./cookiePolicy";

// Run with: pnpm --filter yt-dlp-transcript-common exec tsx --test common/lib/cookiePolicy.test.ts
// (or `node_modules/.bin/tsx --test common/lib/cookiePolicy.test.ts` from the repo root)

test("isCookieMode accepts exactly the three modes", () => {
  assert.equal(isCookieMode("always"), true);
  assert.equal(isCookieMode("when-required"), true);
  assert.equal(isCookieMode("defer"), true);
  assert.equal(isCookieMode(""), false);
  assert.equal(isCookieMode("never"), false);
  assert.equal(isCookieMode(undefined), false);
  assert.equal(isCookieMode(null), false);
  assert.equal(isCookieMode(42), false);
});

test("value resolution: channel > global > undefined; empty/whitespace = inherit", () => {
  assert.equal(
    resolveCookiePolicy({ cookiesFromBrowser: "firefox" }).cookies,
    "firefox",
  );
  assert.equal(
    resolveCookiePolicy(
      { cookiesFromBrowser: "firefox" },
      { cookiesFromBrowser: "chrome:Default" },
    ).cookies,
    "chrome:Default",
  );
  // Empty / whitespace channel value inherits the global.
  assert.equal(
    resolveCookiePolicy(
      { cookiesFromBrowser: "firefox" },
      { cookiesFromBrowser: "" },
    ).cookies,
    "firefox",
  );
  assert.equal(
    resolveCookiePolicy(
      { cookiesFromBrowser: "firefox" },
      { cookiesFromBrowser: "   " },
    ).cookies,
    "firefox",
  );
  // Nothing configured anywhere.
  assert.equal(resolveCookiePolicy({}).cookies, undefined);
  assert.equal(resolveCookiePolicy({ cookiesFromBrowser: "  " }).cookies, undefined);
  // Values are trimmed.
  assert.equal(
    resolveCookiePolicy({ cookiesFromBrowser: "  firefox  " }).cookies,
    "firefox",
  );
});

test("mode resolution: channel > global > default", () => {
  assert.equal(resolveCookiePolicy({}).mode, DEFAULT_COOKIE_MODE);
  assert.equal(resolveCookiePolicy({ cookieMode: "always" }).mode, "always");
  assert.equal(
    resolveCookiePolicy({ cookieMode: "always" }, { cookieMode: "defer" }).mode,
    "defer",
  );
  // Absent channel mode inherits the global.
  assert.equal(
    resolveCookiePolicy({ cookieMode: "defer" }, {}).mode,
    "defer",
  );
  assert.equal(resolveCookiePolicy({ cookieMode: "defer" }, null).mode, "defer");
  // Junk mode (e.g. hand-edited file that bypassed parsing) falls to default.
  assert.equal(
    resolveCookiePolicy({ cookieMode: "sometimes" as never }).mode,
    DEFAULT_COOKIE_MODE,
  );
});

test("accessors encode the mode semantics", () => {
  const p = (mode: ResolvedCookiePolicy["mode"], cookies?: string) =>
    ({ cookies, mode }) as ResolvedCookiePolicy;

  // always: cookies on every invocation, and on retries.
  assert.equal(alwaysCookies(p("always", "firefox")), "firefox");
  assert.equal(authRetryCookies(p("always", "firefox")), "firefox");
  // when-required: never prophylactically, yes on auth retries.
  assert.equal(alwaysCookies(p("when-required", "firefox")), undefined);
  assert.equal(authRetryCookies(p("when-required", "firefox")), "firefox");
  // defer: never.
  assert.equal(alwaysCookies(p("defer", "firefox")), undefined);
  assert.equal(authRetryCookies(p("defer", "firefox")), undefined);

  // No value configured: every accessor degrades to undefined in every mode.
  for (const mode of ["always", "when-required", "defer"] as const) {
    assert.equal(alwaysCookies(p(mode)), undefined);
    assert.equal(authRetryCookies(p(mode)), undefined);
  }
});

test("cookieArgs emits the flag pair or nothing", () => {
  assert.deepEqual(cookieArgs("firefox"), ["--cookies-from-browser", "firefox"]);
  assert.deepEqual(cookieArgs(undefined), []);
  assert.deepEqual(cookieArgs(""), []);
});