import {
  deleteActorFromCache,
  deleteCachedStatus,
  exportUserPublicKeyPem,
  findFavourite,
  findReblog,
  getCachedStatusByObjectId,
  getStatus,
  getStatusByObjectId,
  getUserByUsername,
  listMediaForStatus,
  listProfileFields,
  recordNotification,
  upsertActorCache,
  upsertCachedStatus
} from "./db";
import {
  isDuplicateActivity,
  isFollowedByAnyLocalUser,
  notifyForLocalStatus,
  objectAsJson,
  objectIdString,
  parseActivity,
  recordRemoteActivity,
  resolveRemoteActor,
  sendSignedActivity,
  verifyInboundSignature
} from "./federation";
import { activityJson, json } from "./http";
import {
  ACTIVITY_CONTEXT,
  AVATAR_SVG,
  HEADER_SVG,
  PUBLIC_COLLECTION,
  SECURITY_CONTEXT
} from "./types";
import type { ActorCache, CachedStatus, CachedStatusMention, CachedStatusTag, Json, Media, RemoteActor, Status, User } from "./types";
import {
  actorUrl,
  activityUrl,
  baseUrl,
  clampLimit,
  hostFromBaseUrl,
  id,
  mediaUrl,
  objectUrl,
  profileUrl,
  statusUrl
} from "./util";

export async function webFinger(request: Request, env: Env): Promise<Response> {
  const resource = new URL(request.url).searchParams.get("resource") ?? "";
  const match = resource.match(/^acct:([^@]+)@(.+)$/);
  if (!match) return json({ error: "not_found" }, 404);
  if (match[2].toLowerCase() !== hostFromBaseUrl(env).toLowerCase()) return json({ error: "not_found" }, 404);
  const user = await getUserByUsername(env, match[1]);
  if (!user) return json({ error: "not_found" }, 404);

  return json({
    subject: `acct:${user.username}@${hostFromBaseUrl(env)}`,
    aliases: [actorUrl(env, user), profileUrl(env, user)],
    links: [
      { rel: "self", type: "application/activity+json", href: actorUrl(env, user) },
      { rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: profileUrl(env, user) }
    ]
  }, 200, { "content-type": "application/jrd+json; charset=utf-8" });
}

export async function hostMeta(env: Env): Promise<Response> {
  const xml = `<?xml version="1.0" encoding="UTF-8"?>
<XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">
  <Link rel="lrdd" template="${baseUrl(env)}/.well-known/webfinger?resource={uri}"/>
</XRD>`;
  return new Response(xml, { headers: { "content-type": "application/xrd+xml; charset=utf-8" } });
}

export function nodeInfoLinks(env: Env): Response {
  return json({ links: [{ rel: "http://nodeinfo.diaspora.software/ns/schema/2.0", href: `${baseUrl(env)}/nodeinfo/2.0` }] });
}

export async function nodeInfo(env: Env): Promise<Response> {
  const users = await env.DB.prepare("SELECT COUNT(*) AS count FROM users").first<{ count: number }>();
  const posts = await env.DB.prepare("SELECT COUNT(*) AS count FROM statuses").first<{ count: number }>();
  return json({
    version: "2.0",
    software: { name: "toot-worker", version: "0.3.0" },
    protocols: ["activitypub"],
    services: { inbound: [], outbound: [] },
    usage: { users: { total: users?.count ?? 0 }, localPosts: posts?.count ?? 0 },
    openRegistrations: false,
    metadata: { nodeName: env.INSTANCE_NAME, singleUserMode: true }
  });
}

export async function actor(env: Env, username: string): Promise<Response> {
  const user = await getUserByUsername(env, username);
  if (!user) return json({ error: "not_found" }, 404);
  return activityJson(await actorDocument(env, user));
}

export async function actorDocument(env: Env, user: User): Promise<Json> {
  const url = actorUrl(env, user);
  const profile = profileUrl(env, user);
  const fields = await listProfileFields(env, user.id);
  const avatarUrl = user.avatar_r2_key ? mediaUrl(env, user.avatar_r2_key) : `${baseUrl(env)}/avatar.png`;
  const headerUrl = user.header_r2_key ? mediaUrl(env, user.header_r2_key) : `${baseUrl(env)}/header.png`;
  const avatarMime = guessImageMime(user.avatar_r2_key);
  const headerMime = guessImageMime(user.header_r2_key);
  return {
    "@context": [
      ACTIVITY_CONTEXT,
      SECURITY_CONTEXT,
      {
        manuallyApprovesFollowers: "as:manuallyApprovesFollowers",
        schema: "http://schema.org#",
        PropertyValue: "schema:PropertyValue",
        value: "schema:value"
      }
    ],
    id: url,
    type: "Person",
    preferredUsername: user.username,
    name: user.display_name,
    summary: user.note,
    url: profile,
    inbox: `${url}/inbox`,
    outbox: `${url}/outbox`,
    followers: `${url}/followers`,
    following: `${url}/following`,
    endpoints: { sharedInbox: `${baseUrl(env)}/inbox` },
    icon: { type: "Image", mediaType: avatarMime, url: avatarUrl },
    image: { type: "Image", mediaType: headerMime, url: headerUrl },
    manuallyApprovesFollowers: false,
    discoverable: true,
    attachment: fields.map((field) => ({ type: "PropertyValue", name: field.name, value: field.value })),
    publicKey: {
      id: `${url}#main-key`,
      owner: url,
      publicKeyPem: await exportUserPublicKeyPem(user)
    }
  };
}

function guessImageMime(r2Key: string | null): string {
  if (!r2Key) return "image/svg+xml";
  const ext = r2Key.split(".").pop()?.toLowerCase();
  switch (ext) {
    case "jpg": case "jpeg": return "image/jpeg";
    case "png": return "image/png";
    case "gif": return "image/gif";
    case "webp": return "image/webp";
    case "avif": return "image/avif";
    default: return "image/jpeg";
  }
}

export async function outbox(request: Request, env: Env, username: string): Promise<Response> {
  const user = await getUserByUsername(env, username);
  if (!user) return json({ error: "not_found" }, 404);
  const url = new URL(request.url);
  const wantsPage = url.searchParams.has("page");
  const totalRow = await env.DB.prepare(
    "SELECT COUNT(*) AS count FROM statuses WHERE user_id = ? AND visibility IN ('public', 'unlisted')"
  ).bind(user.id).first<{ count: number }>();
  const totalItems = totalRow?.count ?? 0;
  const base = `${actorUrl(env, user)}/outbox`;

  if (!wantsPage) {
    return activityJson({
      "@context": ACTIVITY_CONTEXT,
      id: base,
      type: "OrderedCollection",
      totalItems,
      first: `${base}?page=true`
    });
  }

  const limit = clampLimit(url.searchParams.get("limit"), 20, 40);
  const rows = await env.DB.prepare(
    "SELECT * FROM statuses WHERE user_id = ? AND visibility IN ('public', 'unlisted') ORDER BY created_at DESC LIMIT ?"
  ).bind(user.id, limit).all<Status>();
  const items = await Promise.all(rows.results.map((status) => createActivity(env, user, status)));
  return activityJson({
    "@context": ACTIVITY_CONTEXT,
    id: `${base}?page=true`,
    partOf: base,
    type: "OrderedCollectionPage",
    orderedItems: items,
    totalItems
  });
}

export async function followersCollection(env: Env, username: string): Promise<Response> {
  const user = await getUserByUsername(env, username);
  if (!user) return json({ error: "not_found" }, 404);
  const row = await env.DB.prepare("SELECT COUNT(*) AS count FROM follows WHERE local_user_id = ? AND accepted = 1").bind(user.id).first<{ count: number }>();
  return activityJson({
    "@context": ACTIVITY_CONTEXT,
    id: `${actorUrl(env, user)}/followers`,
    type: "Collection",
    totalItems: row?.count ?? 0
  });
}

export async function followingCollection(env: Env, username: string): Promise<Response> {
  const user = await getUserByUsername(env, username);
  if (!user) return json({ error: "not_found" }, 404);
  const row = await env.DB.prepare("SELECT COUNT(*) AS count FROM outgoing_follows WHERE local_user_id = ? AND accepted = 1").bind(user.id).first<{ count: number }>();
  return activityJson({
    "@context": ACTIVITY_CONTEXT,
    id: `${actorUrl(env, user)}/following`,
    type: "Collection",
    totalItems: row?.count ?? 0
  });
}

export async function activityObject(env: Env, objectId: string): Promise<Response> {
  const status = await getStatus(env, objectId);
  if (status) {
    if (status.visibility !== "public" && status.visibility !== "unlisted") return json({ error: "not_found" }, 404);
    const user = await env.DB.prepare("SELECT * FROM users WHERE id = ?").bind(status.user_id).first<User>();
    if (!user) return json({ error: "not_found" }, 404);
    const [attachments, tag] = await Promise.all([
      loadStatusAttachments(env, status.id),
      loadStatusTags(env, status.id)
    ]);
    return activityJson(noteObject(env, user, status, { attachments, tag }));
  }
  const tomb = await env.DB.prepare("SELECT * FROM deleted_statuses WHERE id = ?").bind(objectId).first<{ id: string; deleted_at: string }>();
  if (tomb) {
    return activityJson({
      "@context": ACTIVITY_CONTEXT,
      id: `${baseUrl(env)}/objects/${tomb.id}`,
      type: "Tombstone",
      deleted: tomb.deleted_at
    }, 410);
  }
  return json({ error: "not_found" }, 404);
}

export async function inboxHandler(request: Request, env: Env, username: string | null): Promise<Response> {
  const localUser = username ? await getUserByUsername(env, username) : null;
  if (username && !localUser) return json({ error: "not_found" }, 404);

  const bodyText = await request.text();
  const activity = parseActivity(bodyText);
  if (!activity || !activity.type) return json({ error: "invalid_activity" }, 400);
  if (activity.activityId && await isDuplicateActivity(env, activity.activityId)) {
    return new Response(null, { status: 202 });
  }

  const verified = await verifyInboundSignature(request, bodyText, env);
  if (!verified) return json({ error: "invalid_signature" }, 401);
  if (activity.actor && verified.actor.id !== activity.actor) {
    return json({ error: "actor_signature_mismatch" }, 401);
  }
  await recordRemoteActivity(env, activity, true);

  const ctx: InboxContext = {
    env,
    activity,
    actorId: verified.actor.id,
    actorCache: verified.actor,
    localUser
  };

  switch (activity.type) {
    case "Follow":
      return handleFollow(ctx);
    case "Undo":
      return handleUndo(ctx);
    case "Accept":
      return handleAccept(ctx);
    case "Reject":
      return handleReject(ctx);
    case "Like":
      return handleLike(ctx);
    case "Announce":
      return handleAnnounce(ctx);
    case "Delete":
      return handleDelete(ctx);
    case "Update":
      return handleUpdate(ctx);
    case "Create":
      return handleCreate(ctx);
    default:
      return new Response(null, { status: 202 });
  }
}

type InboxContext = {
  env: Env;
  activity: NonNullable<ReturnType<typeof parseActivity>>;
  actorId: string;
  actorCache: ActorCache;
  localUser: User | null;
};

async function handleFollow(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId, actorCache } = ctx;
  const object = objectIdString(activity.body.object);
  const localUser = await localUserFromTarget(env, object) ?? ctx.localUser;
  if (!localUser) return json({ error: "unknown_local_user" }, 404);

  const inbox = actorCache.shared_inbox ?? actorCache.inbox;
  await env.DB.prepare(
    "INSERT OR REPLACE INTO follows (id, follower_actor, local_user_id, inbox, accepted, created_at) VALUES (?, ?, ?, ?, 1, ?)"
  ).bind(id(), actorId, localUser.id, inbox, new Date().toISOString()).run();

  await recordNotification(env, localUser.id, "follow", actorId, null);

  await sendSignedActivity(env, localUser, actorCache.inbox, {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityUrl(env, id()),
    type: "Accept",
    actor: actorUrl(env, localUser),
    object: activity.body
  });
  return new Response(null, { status: 202 });
}

async function handleUndo(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const inner = objectAsJson(activity.body.object);
  if (!inner) return new Response(null, { status: 202 });
  const innerType = String(inner.type ?? "");
  const localUser = ctx.localUser ?? await localUserFromTarget(env, objectIdString(inner.object));
  if (!localUser) return new Response(null, { status: 202 });

  if (innerType === "Follow") {
    await env.DB.prepare("DELETE FROM follows WHERE follower_actor = ? AND local_user_id = ?").bind(actorId, localUser.id).run();
  } else if (innerType === "Like") {
    const target = objectIdString(inner.object);
    if (target) {
      const status = await getStatusByObjectId(env, target);
      if (status) await env.DB.prepare("DELETE FROM favourites WHERE status_id = ? AND actor = ?").bind(status.id, actorId).run();
    }
  } else if (innerType === "Announce") {
    const target = objectIdString(inner.object);
    if (target) {
      const status = await getStatusByObjectId(env, target);
      if (status) await env.DB.prepare("DELETE FROM reblogs WHERE status_id = ? AND actor = ?").bind(status.id, actorId).run();
    }
  }
  return new Response(null, { status: 202 });
}

async function handleAccept(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const inner = objectAsJson(activity.body.object);
  if (!inner || String(inner.type ?? "") !== "Follow") return new Response(null, { status: 202 });
  const innerActor = typeof inner.actor === "string" ? inner.actor : String((inner.actor as Json | undefined)?.id ?? "");
  const localUser = await localUserFromTarget(env, innerActor);
  if (!localUser) return new Response(null, { status: 202 });
  await env.DB.prepare(
    "UPDATE outgoing_follows SET accepted = 1 WHERE local_user_id = ? AND target_actor = ?"
  ).bind(localUser.id, actorId).run();
  return new Response(null, { status: 202 });
}

async function handleReject(ctx: InboxContext): Promise<Response> {
  const { env, actorId } = ctx;
  await env.DB.prepare("DELETE FROM outgoing_follows WHERE target_actor = ?").bind(actorId).run();
  return new Response(null, { status: 202 });
}

async function handleLike(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const target = objectIdString(activity.body.object);
  if (!target) return new Response(null, { status: 202 });
  const status = await getStatusByObjectId(env, target);
  if (!status) return new Response(null, { status: 202 });
  const existing = await findFavourite(env, status.id, actorId);
  if (existing) return new Response(null, { status: 202 });
  await env.DB.prepare(
    "INSERT INTO favourites (id, status_id, actor, activity_id, created_at) VALUES (?, ?, ?, ?, ?)"
  ).bind(id(), status.id, actorId, activity.activityId || id(), new Date().toISOString()).run();
  await notifyForLocalStatus(env, status, "favourite", actorId);
  return new Response(null, { status: 202 });
}

async function handleAnnounce(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const target = objectIdString(activity.body.object);
  if (!target) return new Response(null, { status: 202 });
  const status = await getStatusByObjectId(env, target);
  if (!status) return new Response(null, { status: 202 });
  const existing = await findReblog(env, status.id, actorId);
  if (existing) return new Response(null, { status: 202 });
  await env.DB.prepare(
    "INSERT INTO reblogs (id, status_id, actor, activity_id, created_at) VALUES (?, ?, ?, ?, ?)"
  ).bind(id(), status.id, actorId, activity.activityId || id(), new Date().toISOString()).run();
  await notifyForLocalStatus(env, status, "reblog", actorId);
  return new Response(null, { status: 202 });
}

async function handleDelete(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const target = objectIdString(activity.body.object);
  if (!target) return new Response(null, { status: 202 });

  if (target === actorId) {
    await env.DB.prepare("DELETE FROM follows WHERE follower_actor = ?").bind(actorId).run();
    await env.DB.prepare("DELETE FROM outgoing_follows WHERE target_actor = ?").bind(actorId).run();
    await env.DB.prepare("DELETE FROM favourites WHERE actor = ?").bind(actorId).run();
    await env.DB.prepare("DELETE FROM reblogs WHERE actor = ?").bind(actorId).run();
    await env.DB.prepare("DELETE FROM notifications WHERE actor = ?").bind(actorId).run();
    await env.DB.prepare("DELETE FROM cached_statuses WHERE actor = ?").bind(actorId).run();
    await deleteActorFromCache(env, actorId);
    return new Response(null, { status: 202 });
  }

  await deleteCachedStatus(env, target);
  return new Response(null, { status: 202 });
}

async function handleUpdate(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const obj = objectAsJson(activity.body.object);
  if (!obj) return new Response(null, { status: 202 });
  if (String(obj.type ?? "") === "Person" && obj.id === actorId) {
    await upsertActorCache(env, obj as unknown as RemoteActor);
    return new Response(null, { status: 202 });
  }
  if (String(obj.type ?? "") === "Note" && typeof obj.id === "string") {
    const existing = await getCachedStatusByObjectId(env, obj.id);
    if (existing && existing.actor === actorId) {
      await cacheRemoteNote(env, actorId, obj, activity.body, existing);
    }
  }
  return new Response(null, { status: 202 });
}

async function handleCreate(ctx: InboxContext): Promise<Response> {
  const { env, activity, actorId } = ctx;
  const obj = objectAsJson(activity.body.object);
  if (!obj || String(obj.type ?? "") !== "Note") return new Response(null, { status: 202 });

  const recipients = collectRecipients(activity.body, obj);
  const localActorIds = new Set<string>();
  for (const target of recipients) {
    if (!target.startsWith(baseUrl(env))) continue;
    const m = target.match(/\/users\/([^/?#]+)$/);
    if (m) localActorIds.add(m[1]);
  }

  const isPublic = recipients.includes(PUBLIC_COLLECTION);
  const isFollowersOnly = recipients.some((recipient) => isFollowersCollection(actorId, recipient));
  const followed = await isFollowedByAnyLocalUser(env, actorId);
  if ((followed && (isPublic || isFollowersOnly)) || localActorIds.size > 0) {
    await cacheRemoteNote(env, actorId, obj, activity.body);
  }

  for (const username of localActorIds) {
    const localUser = await getUserByUsername(env, username);
    if (!localUser) continue;
    await recordNotification(env, localUser.id, "mention", actorId, typeof obj.id === "string" ? obj.id : null);
  }
  return new Response(null, { status: 202 });
}

export async function cacheRemoteNote(env: Env, actorId: string, note: Json, activity: Json = {}, fallback?: CachedStatus): Promise<CachedStatus | null> {
  if (typeof note.id !== "string") return null;
  const cachedId = note.id;
  const recipients = collectRecipients(activity, note);
  const mentions = note.tag === undefined ? parseJsonArray<CachedStatusMention>(fallback?.mentions_json) : extractRemoteMentions(note);
  const tags = note.tag === undefined ? parseJsonArray<CachedStatusTag>(fallback?.tags_json) : extractRemoteHashtags(note);
  const localRecipients = recipients.length === 0 ? parseJsonArray<string>(fallback?.local_recipients_json) : collectLocalRecipients(env, recipients);
  const stored = await upsertCachedStatus(env, {
    id: cachedId,
    object_id: cachedId,
    actor: actorId,
    content: typeof note.content === "string" ? note.content : "",
    summary: typeof note.summary === "string" ? note.summary : "",
    sensitive: note.sensitive ? 1 : 0,
    language: typeof note.contentMap === "object" && note.contentMap ? Object.keys(note.contentMap as Json)[0] ?? "en" : "en",
    visibility: inferRemoteVisibility(actorId, activity, note, fallback?.visibility ?? "public"),
    in_reply_to: typeof note.inReplyTo === "string" ? note.inReplyTo : null,
    url: typeof note.url === "string" ? note.url : cachedId,
    published: typeof note.published === "string" ? note.published : new Date().toISOString(),
    mentions_json: JSON.stringify(mentions),
    tags_json: JSON.stringify(tags),
    local_recipients_json: JSON.stringify(localRecipients)
  });
  if (!stored) return null;
  await env.DB.prepare("DELETE FROM cached_status_attachments WHERE cached_status_id = ?").bind(stored.id).run();
  const attachments = Array.isArray(note.attachment) ? note.attachment : note.attachment ? [note.attachment] : [];
  let position = 0;
  for (const raw of attachments) {
    if (!raw || typeof raw !== "object") continue;
    const att = raw as Json;
    const url = typeof att.url === "string" ? att.url
      : (att.url && typeof att.url === "object" && typeof (att.url as Json).href === "string") ? String((att.url as Json).href)
      : null;
    if (!url) continue;
    const mime = typeof att.mediaType === "string" ? att.mediaType : "application/octet-stream";
    const description = typeof att.name === "string" ? att.name
      : typeof att.summary === "string" ? att.summary : null;
    await env.DB.prepare(
      "INSERT OR REPLACE INTO cached_status_attachments (cached_status_id, position, url, preview_url, mime_type, description) VALUES (?, ?, ?, ?, ?, ?)"
    ).bind(stored.id, position, url, null, mime, description).run();
    position++;
  }
  return stored;
}

function inferRemoteVisibility(actorId: string, activity: Json, object: Json, fallback: string): string {
  const to = collectRecipientFields(activity.to, activity.bto, object.to, object.bto);
  const cc = collectRecipientFields(activity.cc, activity.bcc, object.cc, object.bcc);
  const recipients = new Set([...to, ...cc]);
  if (recipients.size === 0) return fallback;
  if (to.has(PUBLIC_COLLECTION)) return "public";
  if (cc.has(PUBLIC_COLLECTION)) return "unlisted";
  if ([...recipients].some((recipient) => isFollowersCollection(actorId, recipient))) return "private";
  return "direct";
}

function isFollowersCollection(actorId: string, recipient: string): boolean {
  return recipient === `${actorId}/followers` || recipient.endsWith("/followers");
}

function collectLocalRecipients(env: Env, recipients: string[]): string[] {
  return recipients.filter((recipient) => recipient.startsWith(baseUrl(env)) && /\/users\/[^/?#]+$/.test(recipient));
}

function extractRemoteMentions(note: Json): CachedStatusMention[] {
  const mentions: CachedStatusMention[] = [];
  for (const tag of noteTagObjects(note)) {
    if (String(tag.type ?? "") !== "Mention") continue;
    const url = stringValue(tag.href) ?? stringValue(tag.id);
    if (!url) continue;
    const acct = mentionAcct(tag, url);
    mentions.push({ actor: url, acct, url });
  }
  return mentions;
}

function extractRemoteHashtags(note: Json): CachedStatusTag[] {
  const tags: CachedStatusTag[] = [];
  for (const tag of noteTagObjects(note)) {
    const name = stringValue(tag.name);
    if (String(tag.type ?? "") !== "Hashtag" && !name?.startsWith("#")) continue;
    if (!name) continue;
    tags.push({ name: name.replace(/^#/, "").toLowerCase(), url: stringValue(tag.href) ?? stringValue(tag.id) });
  }
  return tags;
}

function noteTagObjects(note: Json): Json[] {
  const tags = Array.isArray(note.tag) ? note.tag : note.tag ? [note.tag] : [];
  return tags.filter((tag): tag is Json => Boolean(tag) && typeof tag === "object");
}

function mentionAcct(tag: Json, url: string): string {
  const name = stringValue(tag.name)?.replace(/^@/, "");
  if (name) return name;
  try {
    const parsed = new URL(url);
    const username = parsed.pathname.split("/").filter(Boolean).pop() ?? parsed.host;
    return `${username}@${parsed.host}`;
  } catch {
    return url;
  }
}

function stringValue(value: unknown): string | null {
  return typeof value === "string" && value ? value : null;
}

function parseJsonArray<T>(value: string | null | undefined): T[] {
  if (!value) return [];
  try {
    const parsed = JSON.parse(value) as unknown;
    return Array.isArray(parsed) ? parsed as T[] : [];
  } catch {
    return [];
  }
}

function collectRecipients(activity: Json, object: Json): string[] {
  const fields: unknown[] = [activity.to, activity.cc, activity.bto, activity.bcc, object.to, object.cc, object.bto, object.bcc];
  return [...collectRecipientFields(...fields)];
}

function collectRecipientFields(...fields: unknown[]): Set<string> {
  const out = new Set<string>();
  for (const field of fields) {
    if (Array.isArray(field)) {
      for (const value of field) {
        if (typeof value === "string") out.add(value);
      }
    } else if (typeof field === "string") {
      out.add(field);
    }
  }
  return out;
}

async function localUserFromTarget(env: Env, actorId: string | null): Promise<User | null> {
  if (!actorId) return null;
  if (!actorId.startsWith(baseUrl(env))) return null;
  const match = actorId.match(/\/users\/([^/?#]+)$/);
  if (!match) return null;
  return getUserByUsername(env, match[1]);
}

export async function createActivity(env: Env, user: User, status: Status, extra: { to?: string[]; cc?: string[] } = {}): Promise<Json> {
  const audience = statusAudience(env, user, status);
  const to = extra.to ?? audience.to;
  const cc = extra.cc ?? audience.cc;
  const [attachments, tag] = await Promise.all([
    loadStatusAttachments(env, status.id),
    loadStatusTags(env, status.id)
  ]);
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: status.activity_id,
    type: "Create",
    actor: actorUrl(env, user),
    published: status.created_at,
    to,
    cc,
    object: noteObject(env, user, status, { to, cc, attachments, tag })
  };
}

export async function updateNoteActivity(env: Env, user: User, status: Status, extra: { to?: string[]; cc?: string[] } = {}): Promise<Json> {
  const audience = statusAudience(env, user, status);
  const to = extra.to ?? audience.to;
  const cc = extra.cc ?? audience.cc;
  const [attachments, tag] = await Promise.all([
    loadStatusAttachments(env, status.id),
    loadStatusTags(env, status.id)
  ]);
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityUrl(env, id()),
    type: "Update",
    actor: actorUrl(env, user),
    published: status.edited_at ?? new Date().toISOString(),
    to,
    cc,
    object: noteObject(env, user, status, { to, cc, attachments, tag })
  };
}

export function attachmentObject(env: Env, media: Media): Json {
  return {
    type: media.mime_type.startsWith("image/") ? "Image" : "Document",
    mediaType: media.mime_type,
    url: mediaUrl(env, media.r2_key),
    name: media.description ?? null
  };
}

export async function loadStatusAttachments(env: Env, statusId: string): Promise<Json[]> {
  const media = await listMediaForStatus(env, statusId);
  return media.map((item) => attachmentObject(env, item));
}

export async function loadStatusTags(env: Env, statusId: string): Promise<Json[]> {
  const [mentionRows, hashtagRows] = await Promise.all([
    env.DB.prepare("SELECT actor, acct FROM mentions WHERE status_id = ?").bind(statusId).all<{ actor: string; acct: string }>(),
    env.DB.prepare("SELECT tag FROM hashtags WHERE status_id = ?").bind(statusId).all<{ tag: string }>()
  ]);
  const tags: Json[] = [];
  for (const mention of mentionRows.results) {
    tags.push({ type: "Mention", href: mention.actor, name: `@${mention.acct}` });
  }
  for (const row of hashtagRows.results) {
    tags.push({ type: "Hashtag", href: `${baseUrl(env)}/tags/${encodeURIComponent(row.tag)}`, name: `#${row.tag}` });
  }
  return tags;
}

function statusAudience(env: Env, user: User, status: Status): { to: string[]; cc: string[] } {
  if (status.visibility === "unlisted") {
    return { to: [`${actorUrl(env, user)}/followers`], cc: [PUBLIC_COLLECTION] };
  }
  if (status.visibility === "private") {
    return { to: [`${actorUrl(env, user)}/followers`], cc: [] };
  }
  if (status.visibility === "direct") {
    return { to: [], cc: [] };
  }
  return { to: [PUBLIC_COLLECTION], cc: [`${actorUrl(env, user)}/followers`] };
}

export function deleteActivity(env: Env, user: User, status: Status, extra: { to?: string[]; cc?: string[] } = {}): Json {
  const audience = statusAudience(env, user, status);
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityUrl(env, id()),
    type: "Delete",
    actor: actorUrl(env, user),
    to: extra.to ?? audience.to,
    cc: extra.cc ?? audience.cc,
    object: {
      id: status.object_id,
      type: "Tombstone"
    }
  };
}

export function followActivity(env: Env, user: User, target: string, activityId: string): Json {
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityId,
    type: "Follow",
    actor: actorUrl(env, user),
    object: target
  };
}

export function undoActivity(env: Env, user: User, inner: Json): Json {
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityUrl(env, id()),
    type: "Undo",
    actor: actorUrl(env, user),
    object: inner
  };
}

export function likeActivity(env: Env, user: User, target: string, activityId: string): Json {
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityId,
    type: "Like",
    actor: actorUrl(env, user),
    object: target
  };
}

export function announceActivity(env: Env, user: User, target: string, activityId: string): Json {
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityId,
    type: "Announce",
    actor: actorUrl(env, user),
    published: new Date().toISOString(),
    to: [PUBLIC_COLLECTION],
    cc: [`${actorUrl(env, user)}/followers`],
    object: target
  };
}

export function updatePersonActivity(env: Env, user: User, doc: Json): Json {
  return {
    "@context": [ACTIVITY_CONTEXT, SECURITY_CONTEXT],
    id: activityUrl(env, id()),
    type: "Update",
    actor: actorUrl(env, user),
    to: [PUBLIC_COLLECTION],
    object: doc
  };
}

export function noteObject(env: Env, user: User, status: Status, opts: { to?: string[]; cc?: string[]; attachments?: Json[]; tag?: Json[] } = {}): Json {
  const audience = statusAudience(env, user, status);
  return {
    id: status.object_id,
    type: "Note",
    summary: status.summary || null,
    sensitive: Boolean(status.sensitive),
    inReplyTo: status.in_reply_to_id ? objectUrl(env, status.in_reply_to_id) : null,
    attributedTo: actorUrl(env, user),
    content: status.content,
    published: status.created_at,
    updated: status.edited_at ?? null,
    url: statusUrl(env, user, status.id),
    to: opts.to ?? audience.to,
    cc: opts.cc ?? audience.cc,
    attachment: opts.attachments ?? [],
    tag: opts.tag ?? []
  };
}

export { AVATAR_SVG, HEADER_SVG };