// The one rule for which sites an X channel's posts are built into (release 17
// slice XP). The build that applies it is pinned by
// bin/compose-site.postsVisibility.test.ts.
import { test } from "node:test";
import assert from "node:assert/strict";
import {
  isXPostsChannel,
  postsVisibleTo,
  publishedMemberSlugs,
  xPostsVisibility,
} from "./postsVisibility";
import { isListedSite, parseSite, siteToDisk } from "./siteSchema";
import { sanitizeSocial } from "../social/xCookieSource";

const X = { sourceKind: "social" as const, platform: "twitter" as const };
const BLUESKY = { sourceKind: "social" as const, platform: "bluesky" as const };
const VIDEOS = { platform: "youtube" as const };
const PRIVATE_X = { social: { x: { visibility: "private" } } };
const PUBLIC_X = { social: { x: { visibility: "public" } } };
const publicSite = { audience: undefined };
const privateSite = { audience: "private" as const };

test("an X channel is a social channel on platform twitter, and nothing else is", () => {
  assert.equal(isXPostsChannel(X), true);
  assert.equal(isXPostsChannel(BLUESKY), false);
  assert.equal(isXPostsChannel(VIDEOS), false);
  // A video channel on X (were there one) is not a posts channel.
  assert.equal(isXPostsChannel({ platform: "twitter" }), false);
  assert.equal(isXPostsChannel(null), false);
  assert.equal(isXPostsChannel(undefined), false);
});

test("social.x.visibility: absent and unknown read as public", () => {
  assert.equal(xPostsVisibility({}), "public");
  assert.equal(xPostsVisibility({ social: { x: {} } }), "public");
  assert.equal(xPostsVisibility({ social: { x: { visibility: "hidden" } } }), "public");
  assert.equal(xPostsVisibility(PUBLIC_X), "public");
  assert.equal(xPostsVisibility(PRIVATE_X), "private");
});

test("public: X posts go wherever the channel is a member", () => {
  for (const settings of [{}, PUBLIC_X]) {
    assert.equal(postsVisibleTo(publicSite, X, settings), true);
    assert.equal(postsVisibleTo(privateSite, X, settings), true);
  }
});

test("private: X posts go to private sites only; every other channel is untouched", () => {
  assert.equal(postsVisibleTo(publicSite, X, PRIVATE_X), false);
  assert.equal(postsVisibleTo({}, X, PRIVATE_X), false);
  assert.equal(postsVisibleTo(privateSite, X, PRIVATE_X), true);
  for (const site of [publicSite, privateSite]) {
    assert.equal(postsVisibleTo(site, BLUESKY, PRIVATE_X), true);
    assert.equal(postsVisibleTo(site, VIDEOS, PRIVATE_X), true);
    assert.equal(postsVisibleTo(site, null, PRIVATE_X), true);
  }
});

test("publishedMemberSlugs narrows the membership, in its order", () => {
  const configs: Record<string, object> = { vids: VIDEOS, x: X, sky: BLUESKY };
  const channels = [{ slug: "x" }, { slug: "vids" }, { slug: "sky" }, { slug: "gone" }];
  const configOf = (slug: string) => configs[slug] as typeof X | undefined;
  assert.deepEqual(
    publishedMemberSlugs({ channels }, configOf, PRIVATE_X),
    ["vids", "sky", "gone"],
  );
  assert.deepEqual(
    publishedMemberSlugs({ channels, audience: "private" }, configOf, PRIVATE_X),
    ["x", "vids", "sky", "gone"],
  );
  assert.deepEqual(
    publishedMemberSlugs({ channels }, configOf, {}),
    ["x", "vids", "sky", "gone"],
  );
});

test("site.json audience: only private is kept and written; a private site is never listed", () => {
  assert.equal(parseSite("a", {}).audience, undefined);
  assert.equal(parseSite("a", { audience: "public" }).audience, undefined);
  assert.equal(parseSite("a", { audience: "secret" }).audience, undefined);
  const priv = parseSite("a", { audience: "private" });
  assert.equal(priv.audience, "private");
  assert.equal(siteToDisk(priv).audience, "private");
  assert.equal("audience" in siteToDisk(parseSite("a", {})), false);
  assert.equal(isListedSite(priv), false);
  assert.equal(isListedSite({ ...priv, listed: true }), false);
  assert.equal(isListedSite(parseSite("a", {})), true);
});

test("sanitizeSocial keeps visibility beside cookieSource and drops an unknown one", () => {
  assert.deepEqual(sanitizeSocial({ x: { visibility: "private" } }), {
    x: { visibility: "private" },
  });
  assert.deepEqual(
    sanitizeSocial({ x: { cookieSource: "browser", visibility: "public" } }),
    { x: { cookieSource: "browser", visibility: "public" } },
  );
  assert.deepEqual(sanitizeSocial({ x: { visibility: "nobody" } }), { x: {} });
});