malice

import type { ThreadListEntry, ThreadUnread, TimelineEvent, TimelineItem } from './types';

export interface ThreadEntry {

  room_id: string;

  root_event_id: string;

  preview: string;

  sender: string;

  reply_count: number;

  latest_ms: number;

  pinned: boolean;

  unread: number;

  mentions: number;

}

function previewOf(event: TimelineEvent): string {

  const content = event.content;

  if (content.kind === 'Message') return content.message.media?.caption ?? content.message.body;

  if (content.kind === 'Sticker') return content.body || 'Sticker';

  if (content.kind === 'Poll') return content.question;

  return '';

}

function entryFor(roomId: string, event: TimelineEvent, pinned: boolean): ThreadEntry | null {

  if (!event.event_id || event.thread_root) return null;

  return {

    room_id: roomId,

    root_event_id: event.event_id,

    preview: previewOf(event),

    sender: event.sender.display_name ?? event.sender.user_id,

    reply_count: event.thread_summary?.reply_count ?? 0,

    latest_ms: event.thread_summary?.latest_event_timestamp_ms ?? event.timestamp_ms,

    pinned,

    unread: 0,

    mentions: 0

  };

}

/**

 * Pinned threads first, then by latest activity. The server's thread list wins over roots seen in the

 * loaded timeline, and pins or unread roots that neither has loaded still get a row.

 */

export function roomThreads(

  roomId: string,

  items: TimelineItem[],

  pinnedRoots: string[],

  listed: ThreadListEntry[] = [],

  unreads: Record<string, ThreadUnread> = {}

): ThreadEntry[] {

  const pinned = new Set(pinnedRoots);

  const found = new Map<string, ThreadEntry>();

  for (const item of items) {

    if (item.kind !== 'event') continue;

    const id = item.event.event_id;

    if (!id || (!pinned.has(id) && (item.event.thread_summary?.reply_count ?? 0) === 0)) continue;

    const entry = entryFor(roomId, item.event, pinned.has(id));

    if (entry) found.set(id, entry);

  }

  for (const listedEntry of listed) {

    const entry = entryFor(roomId, listedEntry.root, pinned.has(listedEntry.root_event_id));

    if (!entry) continue;

    found.set(listedEntry.root_event_id, { ...entry, reply_count: listedEntry.reply_count, latest_ms: listedEntry.latest_activity_ms });

  }

  for (const root of new Set([...pinnedRoots, ...Object.keys(unreads)])) {

    if (!found.has(root)) {

      found.set(root, { room_id: roomId, root_event_id: root, preview: '', sender: '', reply_count: 0, latest_ms: 0, pinned: pinned.has(root), unread: 0, mentions: 0 });

    }

  }

  for (const [root, unread] of Object.entries(unreads)) {

    const entry = found.get(root);

    if (entry) found.set(root, { ...entry, unread: unread.messages, mentions: unread.mentions });

  }

  return [...found.values()].sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.latest_ms - a.latest_ms);

}

export function threadMatches(entry: ThreadEntry, query: string): boolean {

  if (!query) return true;

  return entry.preview.toLowerCase().includes(query) || entry.sender.toLowerCase().includes(query);

}